Version bump

The 'act' region used to have 2 trigger vectors ('act' and 'pre'), now
it uses a single "extended" trigger vector where the top bits are what
used to be the used bits in the 'pre' trigger vector. Please see the
description above `TriggerKit`. Also move the extra triggers from the
low end to the high end in the trigger vectors.

.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

.clang-format

@@ -63,6 +63,8 @@ ForEachMacros:
 SortIncludes:    true
 IncludeBlocks:   Regroup
 IncludeCategories:
+  - Regex:           '"V3Pch.*\.h"'
+    Priority:        -2 # Precompiled headers
   - Regex:           '"(config_build|verilated_config|verilatedos)\.h"'
     Priority:        -1 # Sepecials before main header
   - Regex:           '(<|")verilated.*'
@@ -112,6 +114,9 @@ SpacesBeforeTrailingComments: 2
 SpacesInAngles:  false
 SpacesInContainerLiterals: true
 SpacesInCStyleCastParentheses: false
+SpacesInLineCommentPrefix:
+  Minimum: 0
+  Maximum: -1
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
 Standard:        Cpp11

.clang-tidy

@@ -1,4 +1,4 @@
-Checks:          '*,-hicpp*,-android-cloexec-fopen,-cert-dcl50-cpp,-cert-env33-c,-cert-err34-c,-cert-err58-cpp,-clang-analyzer-core.UndefinedBinaryOperatorResult,-clang-analyzer-security*,-cppcoreguidelines-avoid-magic-numbers,-cppcoreguidelines-no-malloc,-cppcoreguidelines-owning-memory,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-constant-array-index,-cppcoreguidelines-pro-bounds-pointer-arithmetic,-cppcoreguidelines-pro-type-const-cast,-cppcoreguidelines-pro-type-reinterpret-cast,-cppcoreguidelines-pro-type-static-cast-downcast,-cppcoreguidelines-pro-type-union-access,-cppcoreguidelines-pro-type-vararg,-cppcoreguidelines-special-member-functions,-fuchsia-*,-google-default-arguments,-google-readability-todo,-google-runtime-references,-llvm-header-guard,-llvm-include-order,-misc-string-integer-assignment,-misc-string-literal-with-embedded-nul,-modernize-use-auto,-modernize-use-trailing-return-type,-readability-braces-around-statements,-readability-container-size-empty,-readability-delete-null-pointer,-readability-else-after-return,-readability-implicit-bool-conversion,-readability-named-parameter,-readability-static-accessed-through-instance'
+Checks:          '*,-hicpp*,-android-cloexec-fopen,-cert-dcl50-cpp,-cert-env33-c,-cert-err34-c,-cert-err58-cpp,-clang-analyzer-core.UndefinedBinaryOperatorResult,-clang-analyzer-security*,-cppcoreguidelines-avoid-magic-numbers,-cppcoreguidelines-no-malloc,-cppcoreguidelines-owning-memory,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-constant-array-index,-cppcoreguidelines-pro-bounds-pointer-arithmetic,-cppcoreguidelines-pro-type-const-cast,-cppcoreguidelines-pro-type-reinterpret-cast,-cppcoreguidelines-pro-type-static-cast-downcast,-cppcoreguidelines-pro-type-union-access,-cppcoreguidelines-pro-type-vararg,-cppcoreguidelines-special-member-functions,-fuchsia-*,-google-default-arguments,-google-readability-todo,-google-runtime-references,-llvm-header-guard,-llvm-include-order,-misc-string-integer-assignment,-misc-string-literal-with-embedded-nul,-modernize-use-auto,-modernize-use-trailing-return-type,-readability-braces-around-statements,-readability-container-size-empty,-readability-delete-null-pointer,-readability-else-after-return,-readability-implicit-bool-conversion,-readability-named-parameter,-readability-static-accessed-through-instance,-llvmlibc-*,-altera-*'
 WarningsAsErrors: ''
 HeaderFilterRegex: ''
 FormatStyle:     none

.codacy.yml

@@ -1,6 +1,6 @@
 ---
 exclude_paths:
-  - '.github/**'
-  - 'ci/build_verilator.sh'
-  - 'include/vltstd/**'
-  - 'nodist/fastcov.py'
+  - ".github/**"  #
+  - "ci/build_verilator.sh"  #
+  - "include/vltstd/**"  #
+  - "nodist/fastcov.py"  #

.codecov.yml

@@ -0,0 +1,20 @@
+---
+# DESCRIPTION: codecov.io config
+#
+# Copyright 2020-2025 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+####################
+# Validate:
+#  curl --data-binary @.codecov.yml https://codecov.io/validate
+#
+coverage:
+  precision: 2
+  range: 75...100
+  round: down
+  status:
+    project: false
+    patch: false
+comment: false

.devcontainer/devcontainer.json

@@ -0,0 +1,8 @@
+{
+        "name": "Verilator Build Environment",
+
+        "build": {
+        "dockerfile": "../ci/docker/buildenv/Dockerfile"
+    }
+
+}

.github/ISSUE_TEMPLATE/bug_report.md

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

.github/ISSUE_TEMPLATE/feature.md

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

.github/ISSUE_TEMPLATE/issue.md

@@ -0,0 +1,24 @@
+---
+name: Bug or feature
+about: Use this to report that something isn't working as expected, or is a desired feature. (Note our contributor agreement at https://github.com/verilator/verilator/blob/master/docs/CONTRIBUTING.rst)
+title: ''
+labels: new
+assignees: ''
+
+---
+
+Thanks for taking the time to report this.
+
+Can you please attach an example that shows the issue or missing feature?  (Must be openly licensed, completely self-contained 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 output from that test indicates it is wrong, and what is the correct or expected output?  (Or, please make test self-checking if possible.)
+
+What 'verilator' command line do we use to run your example?
+
+What 'verilator --version' are you using?  Did you try it with the git master version?  Did you try it with other simulators?
+
+What OS and distribution are you using?
+
+May we assist you in trying to fix this in Verilator yourself?
+
+(Please avoid attaching screenshots that show text - you can convert images to text using e.g. https://ocr.space)

.github/ISSUE_TEMPLATE/questions.md

@@ -8,3 +8,5 @@ assignees: ''
 ---
 
 How may we help - what is your question?
+
+(If reporting a bug or requesting a feature please hit BACK on your browser and use a different issue templates.)

.github/dependabot.yml

@@ -0,0 +1,8 @@
+---
+# See https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/build-test.yml

@@ -0,0 +1,286 @@
+---
+# DESCRIPTION: Github actions config
+# This name is key to badges in README.rst, so we use the name build
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+name: build-test
+
+on:
+  push:
+    branches-ignore:
+      - 'dependabot/**'  # Avoid duplicates: only run the PR, not the push
+  pull_request:
+  workflow_dispatch:
+  schedule:
+    - cron: '0 0 * * 0'  # weekly
+
+permissions:
+  contents: read
+
+defaults:
+  run:
+    working-directory: repo
+
+concurrency:
+  # At most 1 job per branch. Auto cancel on pull requests and on all forks
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' || github.repository != 'verilator/verilator' }}
+
+jobs:
+
+  build-2404-gcc:
+    name: Build | ${{ matrix.os }} | ${{ matrix.cc }}${{ matrix.asan && ' | asan' || '' }}
+    uses: ./.github/workflows/reusable-build.yml
+    with:
+      sha: ${{ github.sha }}
+      os: ${{ matrix.os }}
+      os-name: linux
+      cc: ${{ matrix.cc }}
+      dev-asan: ${{ matrix.asan }}
+      dev-gcov: 0
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - {os: ubuntu-24.04, cc: gcc, asan: 0}
+
+  build-2404-clang:
+    name: Build | ${{ matrix.os }} | ${{ matrix.cc }}${{ matrix.asan && ' | asan' || '' }}
+    uses: ./.github/workflows/reusable-build.yml
+    with:
+      sha: ${{ github.sha }}
+      os: ${{ matrix.os }}
+      os-name: linux
+      cc: ${{ matrix.cc }}
+      dev-asan: ${{ matrix.asan }}
+      dev-gcov: 0
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - {os: ubuntu-24.04, cc: clang, asan: 1}
+
+  build-2204-gcc:
+    name: Build | ${{ matrix.os }} | ${{ matrix.cc }}${{ matrix.asan && ' | asan' || '' }}
+    uses: ./.github/workflows/reusable-build.yml
+    with:
+      sha: ${{ github.sha }}
+      os: ${{ matrix.os }}
+      os-name: linux
+      cc: ${{ matrix.cc }}
+      dev-asan: ${{ matrix.asan }}
+      dev-gcov: 0
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - {os: ubuntu-22.04, cc: gcc, asan: 0}
+
+  build-2204-clang:
+    name: Build | ${{ matrix.os }} | ${{ matrix.cc }}${{ matrix.asan && ' | asan' || '' }}
+    uses: ./.github/workflows/reusable-build.yml
+    with:
+      sha: ${{ github.sha }}
+      os: ${{ matrix.os }}
+      os-name: linux
+      cc: ${{ matrix.cc }}
+      dev-asan: ${{ matrix.asan }}
+      dev-gcov: 0
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - {os: ubuntu-22.04, cc: clang, asan: 0}
+
+  build-osx-gcc:
+    name: Build | ${{ matrix.os }} | ${{ matrix.cc }}${{ matrix.asan && ' | asan' || '' }}
+    uses: ./.github/workflows/reusable-build.yml
+    with:
+      sha: ${{ github.sha }}
+      os: ${{ matrix.os }}
+      os-name: osx
+      cc: ${{ matrix.cc }}
+      dev-asan: ${{ matrix.asan }}
+      dev-gcov: 0
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - {os: macos-15, cc: gcc, asan: 0}
+
+  build-osx-clang:
+    name: Build | ${{ matrix.os }} | ${{ matrix.cc }}${{ matrix.asan && ' | asan' || '' }}
+    uses: ./.github/workflows/reusable-build.yml
+    with:
+      sha: ${{ github.sha }}
+      os: ${{ matrix.os }}
+      os-name: osx
+      cc: ${{ matrix.cc }}
+      dev-asan: ${{ matrix.asan }}
+      dev-gcov: 0
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - {os: macos-15, cc: clang, asan: 0}
+
+  build-windows:
+    name: Build | ${{ matrix.os }} | ${{ matrix.cc }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - {os: windows-2025, cc: msvc}
+    env:
+      CI_OS_NAME: win
+      CCACHE_COMPRESS: 1
+      CCACHE_DIR: ${{ github.workspace }}/.ccache
+      CCACHE_LIMIT_MULTIPLE: 0.95
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          path: repo
+      - name: Cache $CCACHE_DIR
+        uses: actions/cache@v4
+        with:
+          path: ${{ env.CCACHE_DIR }}
+          key: msbuild-msvc-cmake
+      - name: compile
+        env:
+          WIN_FLEX_BISON: ${{ github.workspace }}/.ccache
+        run: ./ci/ci-win-compile.ps1
+      - name: test build
+        run: ./ci/ci-win-test.ps1
+      - name: Zip up repository
+        run: Compress-Archive -LiteralPath install -DestinationPath verilator.zip
+      - name: Upload zip archive
+        uses: actions/upload-artifact@v5
+        with:
+          path: ${{ github.workspace }}/repo/verilator.zip
+          name: verilator-win.zip
+
+  test-2404-gcc:
+    name: Test | ${{ matrix.os }} | ${{ matrix.cc }} | ${{ matrix.reloc && 'reloc | ' || '' }} ${{ matrix.suite }}
+    needs: build-2404-gcc
+    uses: ./.github/workflows/reusable-test.yml
+    with:
+      archive: ${{ needs.build-2404-gcc.outputs.archive }}
+      os: ${{ matrix.os }}
+      cc: ${{ matrix.cc }}
+      reloc: ${{ matrix.reloc }}
+      suite: ${{ matrix.suite }}
+      dev-gcov: 0
+    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}
+
+  test-2404-clang:
+    name: Test | ${{ matrix.os }} | ${{ matrix.cc }} | ${{ matrix.reloc && 'reloc | ' || '' }} ${{ matrix.suite }}
+    needs: build-2404-clang
+    uses: ./.github/workflows/reusable-test.yml
+    with:
+      archive: ${{ needs.build-2404-clang.outputs.archive }}
+      os: ${{ matrix.os }}
+      cc: ${{ matrix.cc }}
+      reloc: ${{ matrix.reloc }}
+      suite: ${{ matrix.suite }}
+      dev-gcov: 0
+    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}
+
+  test-2204-gcc:
+    name: Test | ${{ matrix.os }} | ${{ matrix.cc }} | ${{ matrix.reloc && 'reloc | ' || '' }} ${{ matrix.suite }}
+    needs: build-2204-gcc
+    uses: ./.github/workflows/reusable-test.yml
+    with:
+      archive: ${{ needs.build-2204-gcc.outputs.archive }}
+      os: ${{ matrix.os }}
+      cc: ${{ matrix.cc }}
+      reloc: ${{ matrix.reloc }}
+      suite: ${{ matrix.suite }}
+      dev-gcov: 0
+    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 }} | ${{ matrix.reloc && 'reloc | ' || '' }} ${{ matrix.suite }}
+    needs: build-2204-clang
+    uses: ./.github/workflows/reusable-test.yml
+    with:
+      archive: ${{ needs.build-2204-clang.outputs.archive }}
+      os: ${{ matrix.os }}
+      cc: ${{ matrix.cc }}
+      reloc: ${{ matrix.reloc }}
+      suite: ${{ matrix.suite }}
+      dev-gcov: 0
+    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:
+    name: Lint Python
+    uses: ./.github/workflows/reusable-lint-py.yml
+
+  passed:
+    name: Test suite passed
+    if: always()
+    needs:
+      - build-2404-gcc
+      - build-2404-clang
+      - build-2204-gcc
+      - build-2204-clang
+      - build-osx-gcc
+      - build-osx-clang
+      - build-windows
+      - test-2404-gcc
+      - test-2404-clang
+      - test-2204-gcc
+      - test-2204-clang
+      - lint-py
+
+    runs-on: ubuntu-24.04
+
+    steps:
+      - name: Decide whether the needed jobs succeeded or failed
+        uses: re-actors/alls-green@release/v1
+        with:
+          jobs: ${{ toJSON(needs) }}

.github/workflows/build.yml

@@ -1,164 +0,0 @@
-# DESCRIPTION: Github actions config
-# This name is key to badges in README.rst, so we use the name build
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-
-name: build
-
-on:
-  push:
-  pull_request:
-  workflow_dispatch:
-  schedule:
-  - cron: '0 0 * * 0' # weekly
-
-env:
-  CI_OS_NAME: linux
-  CI_COMMIT: ${{ github.sha }}
-  CCACHE_COMPRESS: 1
-  CCACHE_DIR: ${{ github.workspace }}/.ccache
-  CCACHE_LIMIT_MULTIPLE: 0.95
-
-defaults:
-  run:
-    shell: bash
-    working-directory: repo
-
-jobs:
-
-  build:
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-22.04, ubuntu-20.04]
-        compiler:
-          - { cc: clang, cxx: clang++ }
-          - { cc: gcc,   cxx: g++     }
-        m32: [0, 1]
-        exclude:
-          # Build pull requests only with ubuntu-22.04 and without m32
-          # - os:  ${{ github.event_name == 'pull_request' && 'ubuntu-18.04' || 'do-not-exclude' }}
-          # - os:  ${{ github.event_name == 'pull_request' && 'ubuntu-20.04' || 'do-not-exclude' }}
-          # - m32: ${{ github.event_name == 'pull_request' && 1              || 'do-not-exclude' }}
-          # Build -m32 only on ubuntu-22.04 clang++
-          - {os: ubuntu-18.04, m32: 1}
-          - {os: ubuntu-20.04, m32: 1}
-          - compiler: { cc: gcc, cxx: g++ }
-            m32: 1
-        include:
-          # Build GCC 10 on ubuntu-20.04
-          - os: ubuntu-20.04
-            compiler: { cc: gcc-10, cxx: g++-10 }
-            m32: 0
-    runs-on: ${{ matrix.os }}
-    name: Build | ${{ matrix.os }} | ${{ matrix.compiler.cc }} ${{ matrix.m32 && '| -m32' || '' }}
-    env:
-      CI_BUILD_STAGE_NAME: build
-      CI_RUNS_ON: ${{ matrix.os }}
-      CI_M32: ${{ matrix.m32 }}
-      CC: ${{ matrix.compiler.cc }}
-      CXX: ${{ matrix.compiler.cxx }}
-      CACHE_BASE_KEY: build-${{ matrix.os }}-${{ matrix.compiler.cc }}-m32=${{ matrix.m32 }}
-      CCACHE_MAXSIZE: 250M # Per build matrix entry (2000M in total)
-      VERILATOR_ARCHIVE: verilator-${{ github.sha }}-${{ matrix.os }}-${{ matrix.compiler.cc }}${{ matrix.m32 && '-m32' || '' }}.tar.gz
-    steps:
-
-    - name: Checkout
-      uses: actions/checkout@v3
-      with:
-        path: repo
-
-    - name: Cache $CCACHE_DIR
-      uses: actions/cache@v3
-      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@v3
-      with:
-        path: ${{ github.workspace }}/${{ env.VERILATOR_ARCHIVE }}
-        name: ${{ env.VERILATOR_ARCHIVE }}
-
-
-  test:
-    needs: build
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-22.04, ubuntu-20.04]
-        compiler:
-          - { cc: clang, cxx: clang++ }
-          - { cc: gcc,   cxx: g++     }
-        m32: [0, 1]
-        suite: [dist-vlt-0, dist-vlt-1, dist-vlt-2, vltmt-0, vltmt-1]
-        exclude:
-          # Build pull requests only with ubuntu-22.04 and without m32
-          # - os:  ${{ github.event_name == 'pull_request' && 'ubuntu-18.04' || 'do-not-exclude' }}
-          # - os:  ${{ github.event_name == 'pull_request' && 'ubuntu-20.04' || 'do-not-exclude' }}
-          # - m32: ${{ github.event_name == 'pull_request' && 1              || 'do-not-exclude' }}
-          # Build -m32 only on ubuntu-22.04
-          - {os: ubuntu-18.04, m32: 1}
-          - {os: ubuntu-20.04, m32: 1}
-          - compiler: { cc: gcc, cxx: g++ }
-            m32: 1
-        include:
-          # Test with GCC 10 on ubuntu-20.04 without m32
-          - {os: ubuntu-20.04, compiler: { cc: gcc-10, cxx: g++-10 }, m32: 0, suite: dist-vlt-0}
-          - {os: ubuntu-20.04, compiler: { cc: gcc-10, cxx: g++-10 }, m32: 0, suite: dist-vlt-1}
-          - {os: ubuntu-20.04, compiler: { cc: gcc-10, cxx: g++-10 }, m32: 0, suite: dist-vlt-2}
-          - {os: ubuntu-20.04, compiler: { cc: gcc-10, cxx: g++-10 }, m32: 0, suite: vltmt-0}
-          - {os: ubuntu-20.04, compiler: { cc: gcc-10, cxx: g++-10 }, m32: 0, suite: vltmt-1}
-    runs-on: ${{ matrix.os }}
-    name: Test | ${{ matrix.os }} | ${{ matrix.compiler.cc }} | ${{ matrix.suite }} ${{ matrix.m32 && '| -m32' || '' }}
-    env:
-      CI_BUILD_STAGE_NAME: test
-      CI_RUNS_ON: ${{ matrix.os }}
-      CI_M32: ${{ matrix.m32 }}
-      CC: ${{ matrix.compiler.cc }}
-      CXX: ${{ matrix.compiler.cxx }}
-      CACHE_BASE_KEY: test-${{ matrix.os }}-${{ matrix.compiler.cc }}-m32=${{ matrix.m32 }}-${{ matrix.suite }}
-      CCACHE_MAXSIZE: 64M # Per build matrix entry (2160M in total)
-      VERILATOR_ARCHIVE: verilator-${{ github.sha }}-${{ matrix.os }}-${{ matrix.compiler.cc }}${{ matrix.m32 && '-m32' || '' }}.tar.gz
-    steps:
-
-    - name: Download tar archive
-      uses: actions/download-artifact@v3
-      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@v3
-      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 test dependencies
-      run: ./ci/ci-install.bash
-
-    - name: Test
-      env:
-        TESTS: ${{ matrix.suite }}
-      run: ./ci/ci-script.bash

.github/workflows/contributor.yml

@@ -1,17 +1,20 @@
+---
 # DESCRIPTION: Github actions config
 # SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-
+#
 name: Contributor Agreement
-
 on:
   push:
+    branches-ignore:
+      - 'dependabot/**'  # Avoid duplicates: only run the PR, not the 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@v3
-    - run: test_regress/t/t_dist_contributors.pl
+      - uses: actions/checkout@v5
+      - run: test_regress/t/t_dist_contributors.py

.github/workflows/coverage.yml

@@ -1,99 +1,213 @@
+---
 # DESCRIPTION: Github actions config
 # SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 
-name: coverage
+name: Code coverage
 
 on:
   workflow_dispatch:
   schedule:
-  - cron: '0 0 * * 0' # weekly
+    - cron: '0 0 * * 0'  # weekly
+  pull_request:
+    types: [opened, synchronize, reopened, labeled, unlabeled]
 
-env:
-  CI_OS_NAME: linux
-  CI_COMMIT: ${{ github.sha }}
-  CI_M32: 0
-  COVERAGE: 1
-  VERILATOR_ARCHIVE: verilator-coverage-${{ github.sha }}.tar.gz
+permissions:
+  contents: read
 
 defaults:
   run:
     shell: bash
-    working-directory: repo
+
+concurrency:
+  # At most 1 job per branch. Auto cancel all but scheduled jobs
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name != 'schedule' }}
 
 jobs:
 
+  build:
+    name: Build
+    # 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 coverage 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: dev-coverage')) ||
+      (github.event_name == 'workflow_dispatch')
+    uses: ./.github/workflows/reusable-build.yml
+    with:
+      # For pull requests, build the head of the pull request branch, not the
+      # merge commit, otherwise patch coverage would include the changes
+      # between the root of the pull request and the target branch
+      sha: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
+      os: ubuntu-24.04
+      os-name: linux
+      cc: gcc
+      dev-asan: 0
+      dev-gcov: 1
 
-  Build:
-    runs-on: ubuntu-22.04
-    env:
-      CI_BUILD_STAGE_NAME: build
-      CI_RUNS_ON: ubuntu-22.04
-    steps:
-
-    - name: Checkout
-      uses: actions/checkout@v3
-      with:
-        path: repo
-
-    - 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@v3
-      with:
-        path: ${{ github.workspace }}/${{ env.VERILATOR_ARCHIVE }}
-        name: ${{ env.VERILATOR_ARCHIVE }}
-
-
-  Test:
-    needs: Build
+  test:
+    name: Test | ${{ matrix.test }}${{ matrix.num }}
+    needs: build
+    uses: ./.github/workflows/reusable-test.yml
+    with:
+      archive: ${{ needs.build.outputs.archive }}
+      os: ubuntu-24.04
+      cc: gcc
+      reloc: 0
+      suite: ${{ matrix.test }}${{ matrix.num }}
+      dev-gcov: 1
     strategy:
       fail-fast: false
       matrix:
-        test:
-        - vlt-
-        - vltmt-
-        num:
-        - 0
-        - 1
-        - 2
-        - 3
-        - 4
-        - 5
-        - 6
-        - 7
-        - 8
-        - 9
+        test: [coverage-vlt-, coverage-vltmt-]
+        num: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
         include:
-        - { test: dist, num: '' }
-    runs-on: ubuntu-22.04
-    name: test-${{ matrix.test }}${{ matrix.num }}
-    env:
-      CI_BUILD_STAGE_NAME: test
-      CI_RUNS_ON: ubuntu-22.04
+          - {test: coverage-dist, num: ''}
+
+  publish-codecov:
+    name: Publish results to codecov.io
+    needs: test
+    if: ${{ contains(needs.*.result, 'success') && !cancelled() }}
+    runs-on: ubuntu-24.04
     steps:
+      - name: Checkout
+        uses: actions/checkout@v5
 
-    - name: Download tar archive
-      uses: actions/download-artifact@v3
-      with:
-        name: ${{ env.VERILATOR_ARCHIVE }}
-        path: ${{ github.workspace }}
+      - name: Download code coverage data
+        uses: actions/download-artifact@v6
+        with:
+          pattern: code-coverage-*
+          path: obj_coverage
+          merge-multiple: true
 
-    - name: Unpack tar archive
-      working-directory: ${{ github.workspace }}
-      run: tar -x -z -f ${{ env.VERILATOR_ARCHIVE }}
+      - name: List files
+        id: list-files
+        run: |
+          ls -lsha obj_coverage
+          find obj_coverage -type f | paste -sd, | sed "s/^/files=/" >> "$GITHUB_OUTPUT"
 
-    - name: Install test dependencies
-      run: ./ci/ci-install.bash
+      - name: Upload to codecov.io
+        uses: codecov/codecov-action@v5
+        with:
+          disable_file_fixes: true
+          disable_search: true
+          fail_ci_if_error: true
+          files: ${{ steps.list-files.outputs.files }}
+          plugins: noop
+          token: ${{ secrets.CODECOV_TOKEN }}
+          verbose: true
 
-    - name: Test
-      env:
-        TESTS: coverage-${{ matrix.test }}${{ matrix.num }}
-      run: ./ci/ci-script.bash
+  prepare-report:
+    name: Prepare HTML report
+    needs: [build, test]
+    if: ${{ contains(needs.*.result, 'success') && !cancelled() }}
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Install dependencies
+        run: |
+          echo 'set man-db/auto-update false' | sudo debconf-communicate >/dev/null
+          sudo dpkg-reconfigure man-db
+          sudo apt install lcov
+
+      - name: Download repository archive
+        uses: actions/download-artifact@v6
+        with:
+          name: ${{ needs.build.outputs.archive }}
+          path: ${{ github.workspace }}
+
+      - name: Unpack repository archive
+        run: |
+          tar -x -z -f ${{ needs.build.outputs.archive }}
+          ls -lsha
+
+      - name: Download code coverage data
+        uses: actions/download-artifact@v6
+        with:
+          pattern: code-coverage-*
+          path: repo/obj_coverage
+          merge-multiple: true
+
+      - name: Create report
+        working-directory: repo
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          ls -lsha obj_coverage
+          # Combine reports from test jobs
+          nodist/fastcov.py -C obj_coverage/verilator-*.info --lcov -o obj_coverage/verilator.info
+          # For a PR, report patch coverage against the merge-base between the head of the PR and the target branch
+          if [[ "${{ github.event_name }}" == "pull_request" ]]; then
+            COVERAGE_BASE=$(git rev-parse --short $(git merge-base ${{ github.event.pull_request.base.sha }} ${{ github.event.pull_request.head.sha }}))
+            make coverage-report COVERAGE_BASE=${COVERAGE_BASE} |& tee ${{ github.workspace }}/make-coverage-report.log
+          else
+            make coverage-report
+          fi
+          # Remove data files
+          rm -f obj_coverage/verilator*.info
+          # Some extra work for PRs only
+          if [[ "${{ github.event_name }}" == "pull_request" ]]; then
+            # Save PR number in report
+            echo ${{ github.event.number }} > obj_coverage/pr-number.txt
+            # Generate notification comment content
+            mkdir -p notification
+            echo ${{ github.event.number }} > notification/pr-number.txt
+            NUM=$(gh run view ${{ github.run_id }} --json number --jq ".number")
+            URL=$(gh run view ${{ github.run_id }} --json url    --jq ".url")
+            echo "Patch coverage from PR workflow [#$NUM]($URL) (code coverage of lines changed relative to ${COVERAGE_BASE}):" > notification/body.txt
+            if [[ ! -f obj_coverage/empty-patch ]]; then
+              echo "<pre>" >> notification/body.txt
+              grep -E "(lines|branches)\.*:" ${{ github.workspace }}/make-coverage-report.log | sed "s/\.*:/:/" >> notification/body.txt || true
+              echo "</pre>" >> notification/body.txt
+              echo "Report: [${{ github.run_id }}](https://${{ github.repository_owner }}.github.io/verilator/coverage-reports/${{ github.run_id }}/index.html)" >> notification/body.txt
+            else
+              echo "Patch contains no code changes" >> notification/body.txt
+            fi
+            cat notification/body.txt
+          fi
+
+      - name: Upload report
+        uses: actions/upload-artifact@v5
+        with:
+          path: repo/obj_coverage
+          name: coverage-report
+
+      - name: Upload notification
+        if: ${{ github.event_name == 'pull_request' }}
+        uses: actions/upload-artifact@v5
+        with:
+          path: repo/notification
+          name: coverage-pr-notification
+
+  # Create GitHub issue for failed scheduled jobs
+  # This should always be the last job (we want an issue if anything breaks)
+  create-issue:
+    name: Create issue on failure
+    needs: [publish-codecov, prepare-report]
+    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 Code coverage 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 "Code coverage run #${{ github.run_number }} Failed" \
+            --body-file body.txt \
+            --label new \
+            --assignee gezalore,wsnyder

.github/workflows/docker.yml

@@ -1,13 +1,15 @@
+---
 # Build and push verilator docker image when tags are pushed to the repository.
-# The following secrets must be configured in the github repository:
+# The following variable(s) must be configured in the github repository:
 # DOCKER_HUB_NAMESPACE: docker hub namespace.
+# The following secrets must be configured in the github repository:
 # DOCKER_HUB_USER: user name for logging into docker hub
 # DOCKER_HUB_ACCESS_TOKEN: docker hub access token.
 name: Build Verilator Container
 
 on:
   push:
-    tags: [ 'v*' ]
+    tags: ['v*']
   workflow_dispatch:
     inputs:
       manual_tag:
@@ -20,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:
@@ -33,52 +38,52 @@ jobs:
           # - "ci/docker/buildenv:verilator-buildenv"
 
     steps:
-    - name: Checkout
-      uses: actions/checkout@v3
+      - name: Checkout
+        uses: actions/checkout@v5
 
-    - name: Extract context variables
-      run: |
-        echo "${{ matrix.contexts }}" | sed -r 's/(.*):.*/build_context=\1/' >> "$GITHUB_ENV"
-        echo "${{ matrix.contexts }}" | sed -r 's/.*:(.*)/image_name=\1/' >> "$GITHUB_ENV"
-        echo "git_tag=${GITHUB_REF#refs/*/}" >> "$GITHUB_ENV"
+      - name: Extract context variables
+        run: |
+          echo "${{ matrix.contexts }}" | sed -r 's/(.*):.*/build_context=\1/' >> "$GITHUB_ENV"
+          echo "${{ matrix.contexts }}" | sed -r 's/.*:(.*)/image_name=\1/' >> "$GITHUB_ENV"
+          echo "git_tag=${GITHUB_REF#refs/*/}" >> "$GITHUB_ENV"
 
-    - name: Use manual tag
-      if: ${{ inputs.manual_tag }}
-      run: |
-        echo "git_tag=${{ inputs.manual_tag }}" >> "$GITHUB_ENV"
+      - name: Use manual tag
+        if: ${{ inputs.manual_tag }}
+        run: |
+          echo "git_tag=${{ inputs.manual_tag }}" >> "$GITHUB_ENV"
 
-    - name: Docker meta
-      id: docker_meta
-      uses: docker/metadata-action@v4
-      with:
-        images: |
-          ${{ secrets.DOCKER_HUB_NAMESPACE }}/${{ env.image_name }}
-        tags: |
-          type=match,pattern=(v.*),group=1,enable=${{ startsWith(github.ref, 'refs/tags/v') }}
-          type=raw,value=${{ inputs.manual_tag }},enable=${{ inputs.manual_tag != '' }}
-          type=raw,value=latest,enable=${{ inputs.add_latest_tag == true }}
+      - name: Docker meta
+        id: docker_meta
+        uses: docker/metadata-action@v5
+        with:
+          images: |
+            ${{ vars.DOCKER_HUB_NAMESPACE }}/${{ env.image_name }}
+          tags: |
+            type=match,pattern=(v.*),group=1,enable=${{ startsWith(github.ref, 'refs/tags/v') }}
+            type=raw,value=${{ inputs.manual_tag }},enable=${{ inputs.manual_tag != '' }}
+            type=raw,value=latest,enable=${{ inputs.add_latest_tag == true }}
 
-    - name: Set up QEMU
-      uses: docker/setup-qemu-action@v2
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
 
-    - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v2
-      with:
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
           buildkitd-flags: --debug
 
-    - name: Login to Docker Hub
-      uses: docker/login-action@v2
-      with:
-        username: ${{ secrets.DOCKER_HUB_USER }}
-        password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_HUB_USER }}
+          password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
 
-    - name: Build and Push to Docker
-      uses: docker/build-push-action@v4
-      if: startsWith(github.ref, 'refs/tags/v')
-      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') }}
-        tags: ${{ steps.docker_meta.outputs.tags }}
-        labels: ${{ steps.docker_meta.outputs.labels }}
+      - name: Build and Push to Docker
+        uses: docker/build-push-action@v6
+        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') || github.event_name == 'workflow_dispatch') }}
+          tags: ${{ steps.docker_meta.outputs.tags }}
+          labels: ${{ steps.docker_meta.outputs.labels }}

.github/workflows/format.yml

@@ -1,25 +1,27 @@
+---
 # DESCRIPTION: Github actions config
 # SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-
+#
 name: format
-
 on:
   push:
-  pull_request_target:
-  workflow_dispatch:
+    branches-ignore:
+      - 'dependabot/**'  # Avoid duplicates: only run the PR, not the push
+
+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 }}
-      CI_M32: 0
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v5
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
       - name: Install packages for build
@@ -27,17 +29,18 @@ 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: |
+        run: |-
           if [ -n "$(git status --porcelain)" ]; then
             git commit . -m "Apply 'make format'" &&
             git push origin

.github/workflows/msbuild.yml

@@ -1,51 +0,0 @@
-# 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: msbuild
-
-on:
-  push:
-  pull_request:
-  workflow_dispatch:
-  schedule:
-  - cron: '0 0 * * 0' # weekly
-
-env:
-  CI_OS_NAME: win
-  CI_COMMIT: ${{ github.sha }}
-  CCACHE_COMPRESS: 1
-  CCACHE_DIR: ${{ github.workspace }}/.ccache
-  CCACHE_LIMIT_MULTIPLE: 0.95
-
-defaults:
-  run:
-    working-directory: repo
-
-jobs:
-
-   windows:
-    name: run on windows
-    runs-on: windows-latest
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        path: repo
-    - name: Cache $CCACHE_DIR
-      uses: actions/cache@v3
-      with:
-        path: ${{ env.CCACHE_DIR }}
-        key: msbuild-msvc-cmake
-    - name: compile
-      env:
-        WIN_FLEX_BISON: ${{ github.workspace }}/.ccache
-      run: ./ci/ci-win-compile.ps1
-    - name: test build
-      run: ./ci/ci-win-test.ps1
-    - name: Zip up repository
-      run: Compress-Archive -LiteralPath install -DestinationPath verilator.zip
-    - name: Upload zip archive
-      uses: actions/upload-artifact@v3
-      with:
-        path: ${{ github.workspace }}/repo/verilator.zip
-        name: verilator-win.zip

.github/workflows/pages.yml

@@ -0,0 +1,90 @@
+---
+# DESCRIPTION: Github actions config
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+name: Pages
+
+on:
+  push:
+    branches:
+      - master
+    paths:
+      - "ci/**"
+      - ".github/workflows"
+  workflow_dispatch:
+  workflow_run:
+    workflows: ["Code coverage"]
+    types: [completed]
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+# Allow only one concurrent deployment, skipping runs queued between the run
+# in-progress and latest queued. However, do NOT cancel in-progress runs as we
+# want to allow these deployments to complete.
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  build:
+    name: Build content
+    runs-on: ubuntu-24.04
+    outputs:
+      coverage-pr-run-ids: ${{ steps.build.outputs.coverage-pr-run-ids }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+      - name: Build pages
+        id: build
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          bash -x ./ci/ci-pages.bash
+          ls -lsha
+          tree -L 3 pages
+      - name: Upload pages artifact
+        uses: actions/upload-pages-artifact@v4
+        with:
+          path: pages
+
+  deploy:
+    name: Deploy
+    needs: build
+    runs-on: ubuntu-24.04
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - name: Deploy to GitHub Pages
+        uses: actions/deploy-pages@v4
+
+  notify:
+    name: Notify
+    needs: [build, deploy]
+    runs-on: ubuntu-24.04
+    if: ${{ github.repository == 'verilator/verilator' }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+      # Use the Verilator CI app to post the comment
+      - name: Generate access token
+        id: generate-token
+        uses: actions/[email protected]
+        with:
+          app-id: ${{ vars.VERILATOR_CI_ID }}
+          private-key: ${{ secrets.VERILATOR_CI_KEY }}
+          permission-actions: write
+          permission-pull-requests: write
+      - name: Comment on PR
+        env:
+          GH_TOKEN: ${{ steps.generate-token.outputs.token }}
+          COVERAGE_PR_RUN_IDS: ${{ needs.build.outputs.coverage-pr-run-ids }}
+        run: bash -x ./ci/ci-pages-notify.bash

.github/workflows/reusable-build.yml

@@ -0,0 +1,99 @@
+---
+# DESCRIPTION: Github actions config
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+name: reusable-build
+
+on:
+  workflow_call:
+    inputs:
+      sha:
+        description: "Commit SHA to build"
+        required: true
+        type: string
+      os:  # e.g. ubuntu-24.04
+        required: true
+        type: string
+      cc: # 'clang' or 'gcc'
+        required: true
+        type: string
+      os-name: # 'linux' or 'osx'
+        required: true
+        type: string
+      dev-asan:
+        required: true
+        type: number
+      dev-gcov:
+        required: true
+        type: number
+    outputs:
+      archive:
+        description: "Name of the built repository archive artifact"
+        value: ${{ jobs.build.outputs.archive }}
+
+env:
+  CI_OS_NAME: ${{ inputs.os-name }}
+  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:
+    name: Build
+    runs-on: ${{ inputs.os }}
+    outputs:
+      archive: ${{ steps.create-archive.outputs.archive }}
+    env:
+      CI_BUILD_STAGE_NAME: build
+      CI_DEV_ASAN: ${{ inputs.dev-asan }}
+      CI_DEV_GCOV: ${{ inputs.dev-gcov }}
+      CI_RUNS_ON: ${{ inputs.os }}
+      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)
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+        with:
+          path: repo
+          ref: ${{ inputs.sha }}
+          fetch-depth: ${{ inputs.dev-gcov && '0' || '1' }}  # Coverage flow needs full history
+
+      - 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 }}-${{ inputs.sha }}
+          restore-keys: |
+            ${{ env.CACHE_KEY }}-
+
+      - name: Install packages for build
+        run: ./ci/ci-install.bash
+
+      - name: Build
+        run: ./ci/ci-script.bash
+
+      - name: Create repository archive
+        id: create-archive
+        working-directory: ${{ github.workspace }}
+        run: |
+          # Name of the archive must be unique based on the build parameters
+          ARCHIVE=verilator-${{ inputs.sha }}-${{ inputs.os }}-${{ inputs.cc }}-${{ inputs.dev-asan }}-${{ inputs.dev-gcov }}.tar.gz
+          tar --posix -c -z -f $ARCHIVE repo
+          echo "archive=$ARCHIVE" >> "$GITHUB_OUTPUT"
+
+      - name: Upload repository archive
+        uses: actions/upload-artifact@v5
+        with:
+          path: ${{ github.workspace }}/${{ steps.create-archive.outputs.archive }}
+          name: ${{ steps.create-archive.outputs.archive }}

.github/workflows/reusable-lint-py.yml

@@ -0,0 +1,46 @@
+---
+# DESCRIPTION: Github actions config
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+name: reusable-lint-py
+
+on:
+  workflow_call:
+
+env:
+  CI_OS_NAME: linux
+  CI_BUILD_STAGE_NAME: build
+  CI_RUNS_ON: ubuntu-22.04
+  CCACHE_COMPRESS: 1
+  CCACHE_DIR: ${{ github.workspace }}/.ccache
+  CCACHE_LIMIT_MULTIPLE: 0.95
+
+defaults:
+  run:
+    shell: bash
+    working-directory: repo
+
+jobs:
+
+  lint-py:
+    runs-on: ubuntu-22.04
+    name: Sub-lint | Python
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+        with:
+          path: repo
+
+      - name: Install packages for build
+        run: ./ci/ci-install.bash
+
+    # We use specific version numbers, otherwise a Python package
+    # update may add a warning and break our build
+      - name: Install packages for lint
+        run: sudo pip3 install mypy==1.18.2 pylint==3.0.2 ruff==0.1.3 clang sphinx sphinx_rtd_theme sphinxcontrib-spelling breathe ruff
+
+      - name: Configure
+        run: autoconf && ./configure --enable-longtests --enable-ccwarn
+
+      - name: Lint
+        run: make -k lint-py

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

@@ -0,0 +1,75 @@
+---
+# 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: |
+          echo "path-exclude /usr/share/doc/*"  | sudo tee -a /etc/dpkg/dpkg.cfg.d/01_nodoc
+          echo "path-exclude /usr/share/man/*"  | sudo tee -a /etc/dpkg/dpkg.cfg.d/01_nodoc
+          echo "path-exclude /usr/share/info/*" | sudo tee -a /etc/dpkg/dpkg.cfg.d/01_nodoc
+          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@v5
+        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@v5
+        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: |
+          echo "path-exclude /usr/share/doc/*"  | sudo tee -a /etc/dpkg/dpkg.cfg.d/01_nodoc
+          echo "path-exclude /usr/share/man/*"  | sudo tee -a /etc/dpkg/dpkg.cfg.d/01_nodoc
+          echo "path-exclude /usr/share/info/*" | sudo tee -a /etc/dpkg/dpkg.cfg.d/01_nodoc
+          sudo apt update
+          sudo apt install ccache mold libfl-dev libgoogle-perftools-dev libsystemc-dev
+
+      - name: Download Verilator installation archive
+        uses: actions/download-artifact@v6
+        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@v5
+        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 --timeout 60 --verbose --cases='${{inputs.cases}}' --compileArgs='${{inputs.compileArgs}}' --executeArgs='${{inputs.executeArgs}}' --nExecute=0
+
+      - name: Execute cases
+        working-directory: rtlmeter
+        continue-on-error: true  # Do not fail on error, so we can at least save the successful results
+        run: |
+          ./rtlmeter run --timeout 60 --verbose --cases='${{inputs.cases}}' --compileArgs='${{inputs.compileArgs}}' --executeArgs='${{inputs.executeArgs}}'
+
+      - 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@v5
+        with:
+          path: results-${{ steps.results.outputs.hash }}.json
+          name: rtlmeter-${{ inputs.tag }}-results-${{ 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}}'

.github/workflows/reusable-test.yml

@@ -0,0 +1,105 @@
+---
+# DESCRIPTION: Github actions config
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+name: reusable-test
+
+on:
+  workflow_call:
+    inputs:
+      archive:
+        description: "Name of the repository archive artifact from reusable-build"
+        required: true
+        type: string
+      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
+      dev-gcov:
+        required: true
+        type: number
+
+env:
+  CI_OS_NAME: linux
+  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: Test
+    env:
+      CI_BUILD_STAGE_NAME: test
+      CI_RUNS_ON: ${{ inputs.os }}
+      CI_RELOC: ${{inputs.reloc }}
+      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)
+    steps:
+
+      - name: Download repository archive
+        uses: actions/download-artifact@v6
+        with:
+          name: ${{ inputs.archive }}
+          path: ${{ github.workspace }}
+
+      - name: Unpack repository archive
+        working-directory: ${{ github.workspace }}
+        run: |
+          tar -x -z -f ${{ inputs.archive }}
+          ls -lsha
+
+      - 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
+        id: run-test
+        continue-on-error: true
+        env:
+          TESTS: ${{ inputs.suite }}
+        run: ./ci/ci-script.bash
+
+      - name: Combine code coverage data
+        if: ${{ inputs.dev-gcov }}
+        run: |
+          make coverage-combine
+          mv obj_coverage/verilator.info obj_coverage/verilator-${{ inputs.suite }}.info
+          ls -lsha obj_coverage
+
+      - name: Upload code coverage data
+        if: ${{ inputs.dev-gcov }}
+        uses: actions/upload-artifact@v5
+        with:
+          path: ${{ github.workspace }}/repo/obj_coverage/verilator-${{ inputs.suite }}.info
+          name: code-coverage-${{ inputs.suite }}
+
+      - name: Fail job if a test failed
+        if: ${{ steps.run-test.outcome == 'failure' && !cancelled() }}
+        run: exit 1

.github/workflows/rtlmeter-pr-results.yml

@@ -0,0 +1,48 @@
+---
+# 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 PR results
+
+on:
+  workflow_run:
+    workflows: [RTLMeter]
+    types: [completed]
+
+jobs:
+  publish:
+    name: Publish
+    runs-on: ubuntu-latest
+    if: ${{ github.event.workflow_run.event == 'pull_request' && github.event.workflow_run.conclusion == 'success' }}
+    permissions:
+      actions: read
+      pull-requests: write
+    steps:
+      - name: Download report
+        uses: actions/download-artifact@v6
+        with:
+          name: rtlmeter-pr-results
+          run-id: ${{ github.event.workflow_run.id }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Download PR number
+        uses: actions/download-artifact@v6
+        with:
+          name: pr-number
+          run-id: ${{ github.event.workflow_run.id }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+      # Use the Verilator CI app to post the comment
+      - name: Generate access token
+        id: generate-token
+        uses: actions/[email protected]
+        with:
+          app-id: ${{ vars.VERILATOR_CI_ID }}
+          private-key: ${{ secrets.VERILATOR_CI_KEY }}
+          permission-pull-requests: write
+      - name: Comment on PR
+        env:
+          GH_TOKEN: ${{ steps.generate-token.outputs.token }}
+        run: |-
+          ls -la
+          cat report.txt
+          gh pr --repo ${{ github.repository }} comment $(cat pr-number.txt) --body-file report.txt

.github/workflows/rtlmeter.yml

@@ -0,0 +1,416 @@
+---
+# 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:
+  # At most 1 job per branch. Auto cancel all but scheduled jobs
+  group: ${{ github.workflow }}-${{ 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:
+          - "BlackParrot:1x1:*"
+          - "BlackParrot:2x2:*"
+          - "BlackParrot:4x4:*"
+          - "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:
+          - "BlackParrot:1x1:*"
+          - "BlackParrot:2x2:*"
+          - "BlackParrot:4x4:*"
+          - "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-gcc-hier:
+    name: Run GCC hier | ${{ matrix.cases }}
+    needs: build-gcc
+    uses: ./.github/workflows/reusable-rtlmeter-run.yml
+    with:
+      tag: gcc-hier
+      runs-on: ubuntu-24.04
+      cc: gcc
+      cases: ${{ matrix.cases }}
+      run-name: "gcc --hierarchical"
+      compileArgs: "--hierarchical"
+      executeArgs: ""
+    strategy:
+      fail-fast: false
+      max-parallel: ${{ github.event == 'schedule' && 2 || 7 }}
+      matrix:
+        cases:
+          - "BlackParrot:1x1:* !-hier"
+          - "BlackParrot:2x2:* !-hier"
+          - "BlackParrot:4x4:* !-hier"
+          - "NVDLA:* !-hier"
+          - "OpenPiton:1x1:* !-hier"
+          - "OpenPiton:2x2:* !-hier"
+          - "OpenPiton:4x4:* !-hier"
+          - "OpenPiton:8x8:* !-hier"
+          - "OpenPiton:16x16:dhry !-hier"
+          - "XuanTie-C910:* !-hier"
+
+  combine-results:
+    name: Combine results
+    needs: [run-gcc, run-clang, run-gcc-hier]
+    # 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, gcc-hier]
+    steps:
+      - name: Checkout RTLMeter
+        uses: actions/checkout@v5
+        with:
+          repository: "verilator/rtlmeter"
+          path: rtlmeter
+      - name: Setup RTLMeter venv
+        working-directory: rtlmeter
+        run: make venv
+      - name: Download all results
+        uses: actions/download-artifact@v6
+        with:
+          pattern: rtlmeter-${{ matrix.tag }}-results-*
+          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@v5
+        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@v6
+        with:
+          pattern: all-results-*
+          path: results
+          merge-multiple: true
+      - name: Upload published results
+        uses: actions/upload-artifact@v5
+        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@v5
+        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
+
+  prepare-pr-results:
+    name: Prepare Pull Request results
+    needs: combine-results
+    if: ${{ github.event_name == 'pull_request' && github.repository == 'verilator/verilator' && contains(needs.*.result, 'success') && !cancelled() }}
+    runs-on: ubuntu-24.04
+    permissions:
+      actions: read
+    steps:
+      - name: Checkout RTLMeter
+        uses: actions/checkout@v5
+        with:
+          repository: "verilator/rtlmeter"
+          path: rtlmeter
+      - name: Setup RTLMeter venv
+        working-directory: rtlmeter
+        run: make venv
+      - name: Download combined results
+        uses: actions/download-artifact@v6
+        with:
+          pattern: all-results-*
+          path: all-results
+          merge-multiple: true
+      - name: Get scheduled run info
+        id: scheduled-info
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          ID=$(gh run --repo ${{ github.repository }} list --workflow RTLMeter --event schedule --status success --limit 1 --json databaseId --jq ".[0].databaseId")
+          echo "id=$ID" >> $GITHUB_OUTPUT
+          URL=$(gh run --repo ${{ github.repository }} view $ID --json url --jq ".url")
+          echo "url=$URL" >> $GITHUB_OUTPUT
+          NUM=$(gh run --repo ${{ github.repository }} view $ID --json number --jq ".number")
+          echo "num=$NUM" >> $GITHUB_OUTPUT
+          DATE=$(gh run --repo ${{ github.repository }} view $ID --json createdAt --jq ".createdAt")
+          echo "date=$DATE" >> $GITHUB_OUTPUT
+      - name: Download scheduled run results
+        uses: actions/download-artifact@v6
+        with:
+          name: published-results
+          path: nightly-results
+          run-id: ${{ steps.scheduled-info.outputs.id }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Compare results
+        working-directory: rtlmeter
+        run: |
+          for tag in gcc clang gcc-hier; do
+            ADATA=../nightly-results/all-results-${tag}.json
+            BDATA=../all-results/all-results-${tag}.json
+            touch ../verilate-${tag}.txt
+            touch ../execute-${tag}.txt
+            touch ../cppbuild-${tag}.txt
+            if [[ ! -e $ADATA ]]; then
+              continue
+            fi
+            ./rtlmeter compare --cases '* !Example:* !*:hello' --steps "verilate" --metrics "elapsed memory"              $ADATA $BDATA > ../verilate-${tag}.txt
+            cat ../verilate-${tag}.txt
+            ./rtlmeter compare --cases '* !Example:* !*:hello' --steps "execute"  --metrics "speed memory elapsed"        $ADATA $BDATA > ../execute-${tag}.txt
+            cat ../execute-${tag}.txt
+            ./rtlmeter compare --cases '* !Example:* !*:hello' --steps "cppbuild" --metrics "elapsed memory cpu codeSize" $ADATA $BDATA > ../cppbuild-${tag}.txt
+            cat ../cppbuild-${tag}.txt
+          done
+      - name: Create report
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -x
+          NUM=$(gh run --repo ${{ github.repository }} view ${{ github.run_id }} --json number --jq ".number")
+          URL=$(gh run --repo ${{ github.repository }} view ${{ github.run_id }} --json url    --jq ".url")
+          echo -n "Performance metrics for PR workflow [#$NUM]($URL) (B) compared to scheduled run" > report.txt
+          echo -n " [#${{ steps.scheduled-info.outputs.num }}](${{ steps.scheduled-info.outputs.url }}) (A)" >> report.txt
+          echo    " from ${{ steps.scheduled-info.outputs.date }}" >> report.txt
+          for tag in gcc clang gcc-hier; do
+            echo "" >> report.txt
+            if [[ $tag == "gcc" ]]; then
+              echo "<details open>" >> report.txt
+            else
+              echo "<details>" >> report.txt
+            fi
+            echo -n "<summary><strong><em>" >> report.txt
+            jq -rj ".[0].runName" all-results/all-results-${tag}.json >> report.txt
+            echo "</em></strong></summary>" >> report.txt
+            awk -v RS= -v tag=${tag} '{print > sprintf("frag-%02d-verilate-%s.txt",NR,tag)}' verilate-${tag}.txt
+            awk -v RS= -v tag=${tag} '{print > sprintf("frag-%02d-execute-%s.txt" ,NR,tag)}'  execute-${tag}.txt
+            awk -v RS= -v tag=${tag} '{print > sprintf("frag-$02d-cppbuild-%s.txt",NR,tag)}' cppbuild-${tag}.txt
+            for f in $(ls -1 frag-*-verilate-${tag}.txt | sort) $(ls -1 frag-*-execute-${tag}.txt | sort) $(ls -1 frag-*-cppbuild-${tag}.txt | sort); do
+              if [[ $f == frag-01-verilate-${tag}.txt || $f == frag-01-execute-${tag}.txt ]]; then
+                echo "<details open>" >> report.txt
+              else
+                echo "<details>" >> report.txt
+              fi
+              echo -n "<summary>" >> report.txt
+              head -n 1 $f | tr -d '\n' >> report.txt
+              echo "</summary>" >> report.txt
+              echo '<pre>' >> report.txt
+              tail -n +2 $f >> report.txt
+              echo '</pre>' >> report.txt
+              echo "</details>" >> report.txt
+            done
+            echo "</details>" >> report.txt
+          done
+          cat report.txt
+      - name: Upload report
+        uses: actions/upload-artifact@v5
+        with:
+          path: report.txt
+          name: rtlmeter-pr-results
+      - name: Save PR number
+        run: echo ${{ github.event.number }} > pr-number.txt
+      - name: Upload PR number
+        uses: actions/upload-artifact@v5
+        with:
+          path: pr-number.txt
+          name: pr-number
+
+  # Create GitHub issue for failed scheduled 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

.gitignore

@@ -29,15 +29,25 @@ dddrun*
 doxygen-doc
 gdbrun*
 gmon.out
-ncverilog.history
 internals.txt
+ncverilog.history
+nohup.out
+verilator-config-version.cmake
+verilator-config.cmake
+verilator.pc
 verilator.txt
 verilator_bin*
 verilator_coverage_bin*
-verilator.pc
-verilator-config.cmake
-verilator-config-version.cmake
 **/__pycache__/*
 **/_build/*
 **/obj_dir/*
 /.vscode/
+/.idea/
+/cmake-build-*/
+/obj_coverage/
+/test_regress/snapshot/
+xmverilog.*
+xrun.history
+
+# Normal CMake build directory
+/build

.pre-commit-hooks.yaml

@@ -0,0 +1,8 @@
+---
+- id: verilator
+  name: verilator-lint
+  description: Runs verilator Docker image to lint (System) Verilog designs
+  args: [--lint-only]
+  language: docker_image
+  entry: verilator/verilator:latest
+  types_or: [verilog, system-verilog]

.style.yapf

@@ -0,0 +1,4 @@
+[style]
+based_on_style = pep8
+column_limit = 99
+#split_before_arithmetic_operator=True

CITATION.cff

@@ -0,0 +1,27 @@
+# See https://citation-file-format.github.io/
+cff-version: 1.2.0
+title: Verilator
+message: >-
+  If you use this software, please cite it using the
+  metadata from this file.
+type: software
+authors:
+  - given-names: Wilson
+    family-names: Snyder
+    email: [email protected]
+    affiliation: Veripool
+  - given-names: Paul
+    family-names: Wasson
+  - given-names: Duane
+    family-names: Galbi
+  - name: 'et al'
+repository-code: 'https://github.com/verilator/verilator'
+url: 'https://verilator.org'
+abstract: >-
+  The Verilator package converts Verilog and SystemVerilog hardware
+  description language (HDL) designs into a fast C++ or SystemC model
+  that, after compiling, can be executed.  Verilator is not a
+  traditional simulator but a compiler.
+license:
+  - LGPL-3.0-only
+  - Artistic-2.0

CMakeLists.txt

@@ -4,7 +4,7 @@
 #
 #*****************************************************************************
 #
-# Copyright 2003-2023 by Wilson Snyder. This program is free software; you
+# Copyright 2003-2025 by Wilson Snyder. This program is free software; you
 # can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
@@ -14,48 +14,92 @@
 
 cmake_minimum_required(VERSION 3.15)
 cmake_policy(SET CMP0091 NEW) # Use MSVC_RUNTIME_LIBRARY to select the runtime
-project(Verilator
-    VERSION 5.014
+project(
+    Verilator
+    VERSION 5.042
     HOMEPAGE_URL https://verilator.org
     LANGUAGES CXX
 )
 
-option(DEBUG_AND_RELEASE_AND_COVERAGE
-    "Builds both the debug and release binaries, overriding CMAKE_BUILD_TYPE. Not supported under MSBuild.")
+# Set default build type to Release if not specified
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Build type" FORCE)
+endif()
+
+option(
+    DEBUG_AND_RELEASE_AND_COVERAGE
+    "Builds both the debug and release binaries, overriding CMAKE_BUILD_TYPE. Not supported under MSBuild."
+)
 
 find_package(Python3 COMPONENTS Interpreter)
-set(PYTHON3 Python3::Interpreter)
-set(CMAKE_INSTALL_DATADIR ${CMAKE_INSTALL_PREFIX})
+set(PYTHON3 ${Python3_EXECUTABLE})
+# See also CMake built-in; CMAKE_INSTALL_PREFIX is applied by the install command.
+set(CMAKE_INSTALL_DATADIR .)
 include(GNUInstallDirs)
 include(CMakePackageConfigHelpers)
 include(CheckStructHasMember)
 include(ExternalProject)
+include(FindThreads)
 
-if (NOT WIN32)
+if(NOT WIN32)
     message(WARNING "CMake support on Linux/OSX is experimental.")
 endif()
 
-if (MSVC)
-    if (DEFINED ENV{WIN_FLEX_BISON})
+if(WIN32)
+    if(DEFINED ENV{WIN_FLEX_BISON})
         set(WIN_FLEX_BISON "$ENV{WIN_FLEX_BISON}")
     endif()
-    if (EXISTS ${WIN_FLEX_BISON})
+    if(IS_DIRECTORY ${WIN_FLEX_BISON})
         list(APPEND CMAKE_PREFIX_PATH ${WIN_FLEX_BISON})
+    else()
+        message(
+            FATAL_ERROR
+            "The path specified by WIN_FLEX_BISON environment variable is not an existing folder: ${WIN_FLEX_BISON}"
+        )
     endif()
-    if (NOT WIN_FLEX_BISON)
-        message(FATAL_ERROR "Please install https://github.com/lexxmark/winflexbison and set WIN_FLEX_BISON environment variable. Please use install cmake target after a successful build.")
+    if(NOT WIN_FLEX_BISON)
+        message(
+            FATAL_ERROR
+            "Please install https://github.com/lexxmark/winflexbison and set WIN_FLEX_BISON environment variable. Please use install cmake target after a successful build."
+        )
     endif()
     set(CMAKE_CXX_STANDARD 20)
 endif()
 
+set(OBJCACHE "" CACHE STRING "Path for ccache, auto-detected if empty")
+option(OBJCACHE_ENABLED "Compile Verilator with ccache" ON)
+
+if(OBJCACHE_ENABLED)
+    if(OBJCACHE STREQUAL "")
+        find_program(OBJCACHE_PATH ccache)
+        if(OBJCACHE_PATH STREQUAL "OBJCACHE_PATH-NOTFOUND")
+            set(OBJCACHE_PATH "")
+        endif()
+    else()
+        set(OBJCACHE_PATH "${OBJCACHE}")
+    endif()
+    if(NOT OBJCACHE_PATH STREQUAL "")
+        execute_process(
+            COMMAND "${OBJCACHE_PATH}" --version
+            OUTPUT_VARIABLE objcache_version
+        )
+        string(REGEX MATCH "[^\n\r]+" objcache_version "${objcache_version}")
+        message(
+            STATUS
+            "Found ccache: ${OBJCACHE_PATH} (\"${objcache_version}\")"
+        )
+        set(CMAKE_CXX_COMPILER_LAUNCHER "${OBJCACHE_PATH}")
+    endif()
+endif()
+
 find_package(BISON)
 find_package(FLEX)
 
 # Build
 #set_property(GLOBAL PROPERTY JOB_POOLS one_job=1)
 
-if (DEBUG_AND_RELEASE_AND_COVERAGE)
-    if (CMAKE_GENERATOR MATCHES "^Visual Studio ")
+if(DEBUG_AND_RELEASE_AND_COVERAGE)
+    if(CMAKE_GENERATOR MATCHES "^Visual Studio ")
         error("%Error: The DEBUG_AND_RELEASE_AND_COVERAGE option is not supported in MSBuild-based builds.")
     endif()
     set(saved_build_type ${CMAKE_BUILD_TYPE})
@@ -74,44 +118,69 @@ endif()
 
 set(PACKAGE_NAME ${PROJECT_NAME})
 set(PACKAGE_VERSION ${PROJECT_VERSION})
+set(CXX ${CMAKE_CXX_COMPILER})
+set(AR ${CMAKE_AR})
 
 configure_file(include/verilated_config.h.in include/verilated_config.h @ONLY)
+configure_file(include/verilated.mk.in include/verilated.mk @ONLY)
 
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/include/verilated_config.h DESTINATION ${CMAKE_INSTALL_PREFIX}/include)
-
-configure_package_config_file(verilator-config.cmake.in verilator-config.cmake
-    INSTALL_DESTINATION ${CMAKE_INSTALL_PREFIX}
+install(
+    FILES ${CMAKE_CURRENT_BINARY_DIR}/include/verilated_config.h
+    DESTINATION include
+)
+install(
+    FILES ${CMAKE_CURRENT_BINARY_DIR}/include/verilated.mk
+    DESTINATION include
 )
 
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/verilator-config.cmake DESTINATION ${CMAKE_INSTALL_PREFIX})
-
-configure_package_config_file(verilator-config-version.cmake.in verilator-config-version.cmake
-    INSTALL_DESTINATION ${CMAKE_INSTALL_PREFIX}
+configure_package_config_file(
+    verilator-config.cmake.in
+    verilator-config.cmake
+    INSTALL_DESTINATION .
 )
 
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/verilator-config-version.cmake DESTINATION ${CMAKE_INSTALL_PREFIX})
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/verilator-config.cmake DESTINATION .)
 
-foreach (program
+configure_package_config_file(
+    verilator-config-version.cmake.in
+    verilator-config-version.cmake
+    INSTALL_DESTINATION .
+)
+
+install(
+    FILES ${CMAKE_CURRENT_BINARY_DIR}/verilator-config-version.cmake
+    DESTINATION .
+)
+
+foreach(
+    program
     verilator
     verilator_gantt
     verilator_ccache_report
     verilator_difftree
     verilator_profcfunc
+    verilator_includer
 )
     install(PROGRAMS bin/${program} TYPE BIN)
 endforeach()
 
-install(DIRECTORY examples TYPE DATA FILES_MATCHING
+install(
+    DIRECTORY examples
+    TYPE DATA
+    FILES_MATCHING
     PATTERN "examples/*/*.[chv]*"
     PATTERN "examples/*/Makefile*"
     PATTERN "examples/*/CMakeLists.txt"
 )
 
-install(DIRECTORY include TYPE DATA FILES_MATCHING
+install(
+    DIRECTORY include
+    TYPE DATA
+    FILES_MATCHING
     PATTERN "include/verilated_config.h"
-    PATTERN "include/verilated.mk"
     PATTERN "include/*.[chv]"
     PATTERN "include/*.cpp"
+    PATTERN "include/*.vlt"
     PATTERN "include/*.sv"
     PATTERN "include/gtkwave/*.[chv]*"
     PATTERN "include/vltstd/*.[chv]*"

Makefile.in

@@ -7,7 +7,7 @@
 #
 #*****************************************************************************
 #
-# Copyright 2003-2023 by Wilson Snyder. This program is free software; you
+# Copyright 2003-2025 by Wilson Snyder. This program is free software; you
 # can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
@@ -52,6 +52,7 @@ INSTALL_PROGRAM = @INSTALL_PROGRAM@
 INSTALL_DATA = @INSTALL_DATA@
 MAKEINFO = makeinfo
 POD2TEXT = pod2text
+PYTHON3 = @PYTHON3@
 MKINSTALLDIRS = $(SHELL) $(srcdir)/src/mkinstalldirs
 
 # Version (for docs/guide/conf.py)
@@ -76,7 +77,7 @@ datadir = @datadir@
 # Directory in which to install documentation info files.
 infodir = @infodir@
 
-# Directory in which to install package specific files
+# Directory in which to install package-specific files
 # Generally ${prefix}/share/verilator
 pkgdatadir = @pkgdatadir@
 
@@ -90,62 +91,68 @@ datarootdir = @datarootdir@
 # Compile options
 CFG_WITH_CCWARN = @CFG_WITH_CCWARN@
 CFG_WITH_DEFENV = @CFG_WITH_DEFENV@
+CFG_WITH_DEV_GCOV = @CFG_WITH_DEV_GCOV@
 CFG_WITH_LONGTESTS = @CFG_WITH_LONGTESTS@
+CFG_WITH_SOLVER = @CFG_WITH_SOLVER@
 PACKAGE_VERSION = @PACKAGE_VERSION@
 
 #### End of system configuration section. ####
 ######################################################################
+# Main build targets
 
 .SUFFIXES:
 
 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/xml_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"
 	$(MAKE) -C src $(OBJCACHE_JOBS)
 
-.PHONY:msg_test
+######################################################################
+# Tests
+
+.PHONY: msg_test
 msg_test: all_nomsg
 	@echo "Build complete!"
 	@echo
@@ -155,7 +162,7 @@ msg_test: all_nomsg
 .PHONY: test
 ifeq ($(CFG_WITH_LONGTESTS),yes)  # Local... Else don't burden users
 test: smoke-test test_regress
-# examples is part of test_regress's test_regress/t/t_a2_examples.pl
+# examples is part of test_regress's test_regress/t/t_a2_examples.py
 # (because that allows it to run in parallel with other test_regress's)
 else
 test: smoke-test examples
@@ -167,19 +174,26 @@ endif
 	@echo
 
 smoke-test: all_nomsg
-	test_regress/t/t_a1_first_cc.pl
-	test_regress/t/t_a2_first_sc.pl
+	test_regress/t/t_a1_first_cc.py
+	test_regress/t/t_a2_first_sc.py
 
 test_regress: all_nomsg
 	$(MAKE) -C test_regress
 
+.PHONY: test-snap test-diff
+test-snap test-diff:
+	$(MAKE) -C test_regress $@
+
 examples: all_nomsg
 	for p in $(EXAMPLES) ; do \
-	  $(MAKE) -C $$p VERILATOR_ROOT=`pwd` || exit 10; \
+		$(MAKE) -C $$p VERILATOR_ROOT=`pwd` || exit 10; \
 	done
 
+######################################################################
+# Docs
+
 .PHONY: docs
-docs: info
+docs: info $(VL_INST_MAN_FILES)
 
 info: $(INFOS)
 
@@ -188,7 +202,8 @@ verilator.1: ${srcdir}/bin/verilator
 verilator_coverage.1: ${srcdir}/bin/verilator_coverage
 	pod2man $< $@
 %.1: ${srcdir}/bin/%
-	help2man --no-info --no-discard-stderr --version-string=- $< -o $@
+	help2man --no-info --no-discard-stderr --version-string=- \
+		-n "$(shell $< --help | head -n 3 | tail -n 1)" $< -o $@
 
 .PHONY: verilator.html
 verilator.html:
@@ -199,56 +214,107 @@ verilator.html:
 verilator.pdf: Makefile
 	$(MAKE) -C docs verilator.pdf
 
-# See uninstall also - don't put wildcards in this variable, it might uninstall other stuff
-VL_INST_BIN_FILES = verilator verilator_bin$(EXEEXT) verilator_bin_dbg$(EXEEXT) verilator_coverage_bin_dbg$(EXEEXT) \
-	verilator_ccache_report verilator_coverage verilator_difftree verilator_gantt verilator_includer verilator_profcfunc
-# Some scripts go into both the search path and pkgdatadir,
-# so they can be found by the user, and under $VERILATOR_ROOT.
+TAGFILES = ${srcdir}/*/*.cpp ${srcdir}/*/*.h ${srcdir}/*/*.in \
+  ${srcdir}/*.in ${srcdir}/*.pod
+
+TAGS: $(TAGFILES)
+	etags $(TAGFILES)
+
+.PHONY: doxygen
+
+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_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_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/*.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_* \
 
-installbin:
-	$(MKINSTALLDIRS) $(DESTDIR)$(bindir)
-	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator $(DESTDIR)$(bindir)/verilator )
-	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_coverage $(DESTDIR)$(bindir)/verilator_coverage )
-	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_gantt $(DESTDIR)$(bindir)/verilator_gantt )
-	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_profcfunc $(DESTDIR)$(bindir)/verilator_profcfunc )
-	( cd bin ; $(INSTALL_PROGRAM) verilator_bin$(EXEEXT) $(DESTDIR)$(bindir)/verilator_bin$(EXEEXT) )
-	( cd bin ; $(INSTALL_PROGRAM) verilator_bin_dbg$(EXEEXT) $(DESTDIR)$(bindir)/verilator_bin_dbg$(EXEEXT) )
-	( cd bin ; $(INSTALL_PROGRAM) verilator_coverage_bin_dbg$(EXEEXT) $(DESTDIR)$(bindir)/verilator_coverage_bin_dbg$(EXEEXT) )
+mkbindirs:
 	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/bin
-	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_includer $(DESTDIR)$(pkgdatadir)/bin/verilator_includer )
-	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_ccache_report $(DESTDIR)$(pkgdatadir)/bin/verilator_ccache_report )
-	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_difftree $(DESTDIR)$(pkgdatadir)/bin/verilator_difftree )
+	$(MKINSTALLDIRS) $(DESTDIR)$(bindir)
+
+installbin: | mkbindirs
+	cd $(srcdir)/bin; \
+	for p in $(VL_INST_PUBLIC_SCRIPT_FILES) ; do \
+		$(INSTALL_PROGRAM) $$p $(DESTDIR)$(bindir)/$$p; \
+	done
+	perl -p -i -e 'use File::Spec;' \
+	           -e' $$path = File::Spec->abs2rel("$(realpath $(DESTDIR)$(pkgdatadir))", "$(realpath $(DESTDIR)$(bindir))");' \
+	           -e 's/my \$$verilator_pkgdatadir_relpath = .*/my \$$verilator_pkgdatadir_relpath = "$$path";/g' \
+	           -- "$(DESTDIR)/$(bindir)/verilator"
+	cd bin; \
+	for p in $(VL_INST_PUBLIC_BIN_FILES) ; do \
+		$(INSTALL_PROGRAM) $$p $(DESTDIR)$(bindir)/$$p; \
+	done
+	cd $(srcdir)/bin; \
+	for p in $(VL_INST_PRIVATE_SCRIPT_FILES) ; do \
+		$(INSTALL_PROGRAM) $$p $(DESTDIR)$(pkgdatadir)/bin/$$p; \
+	done
+
+installredirect: installbin | mkbindirs
+	cp ${srcdir}/bin/redirect ${srcdir}/bin/redirect.tmp
+	perl -p -i -e 'use File::Spec;' \
+	           -e' $$path = File::Spec->abs2rel("$(realpath $(DESTDIR)$(bindir))", "$(realpath $(DESTDIR)$(pkgdatadir)/bin)");' \
+	           -e 's/RELPATH.*/"$$path";/g' -- "${srcdir}/bin/redirect.tmp"
+	cd $(srcdir)/bin; \
+	for p in $(VL_INST_PUBLIC_SCRIPT_FILES) $(VL_INST_PUBLIC_BIN_FILES) ; do \
+		$(INSTALL_PROGRAM) redirect.tmp $(DESTDIR)$(pkgdatadir)/bin/$$p; \
+	done
+	rm ${srcdir}/bin/redirect.tmp
 
 # Man files can either be part of the original kit, or built in current directory
 # So important we use $^ so VPATH is searched
 installman: $(VL_INST_MAN_FILES)
 	$(MKINSTALLDIRS) $(DESTDIR)$(mandir)/man1
 	for p in $^ ; do \
-	  $(INSTALL_DATA) $$p $(DESTDIR)$(mandir)/man1/$$p; \
+		$(INSTALL_DATA) $$p $(DESTDIR)$(mandir)/man1/$$p; \
 	done
 
 installdata:
 	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/include/gtkwave
 	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/include/vltstd
 	for p in $(VL_INST_INC_BLDDIR_FILES) ; do \
-	  $(INSTALL_DATA) $$p $(DESTDIR)$(pkgdatadir)/$$p; \
+		$(INSTALL_DATA) $$p $(DESTDIR)$(pkgdatadir)/$$p; \
 	done
 	cd $(srcdir) \
 	; for p in $(VL_INST_INC_SRCDIR_FILES) ; do \
@@ -265,7 +331,7 @@ installdata:
 	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/examples/cmake_tracing_c
 	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/examples/cmake_tracing_sc
 	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/examples/cmake_protect_lib
-	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/examples/xml_py
+	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/examples/json_py
 	cd $(srcdir) \
 	; for p in $(VL_INST_DATA_SRCDIR_FILES) ; do \
 	  $(INSTALL_DATA) $$p $(DESTDIR)$(pkgdatadir)/$$p; \
@@ -277,8 +343,11 @@ installdata:
 
 # We don't trust rm -rf, so rmdir instead as it will fail if user put in other files
 uninstall:
-	-cd $(DESTDIR)$(bindir) && rm -f $(VL_INST_BIN_FILES)
-	-cd $(DESTDIR)$(pkgdatadir)/bin && rm -f $(VL_INST_BIN_FILES)
+	-cd $(DESTDIR)$(bindir) && rm -f $(VL_INST_PUBLIC_SCRIPT_FILES)
+	-cd $(DESTDIR)$(bindir) && rm -f $(VL_INST_PUBLIC_BIN_FILES)
+	-cd $(DESTDIR)$(pkgdatadir)/bin && rm -f $(VL_INST_PUBLIC_SCRIPT_FILES)
+	-cd $(DESTDIR)$(pkgdatadir)/bin && rm -f $(VL_INST_PUBLIC_BIN_FILES)
+	-cd $(DESTDIR)$(pkgdatadir)/bin && rm -f $(VL_INST_PRIVATE_SCRIPT_FILES)
 	-cd $(DESTDIR)$(mandir)/man1 && rm -f $(VL_INST_MAN_FILES)
 	-cd $(DESTDIR)$(pkgdatadir) && rm -f $(VL_INST_INC_BLDDIR_FILES)
 	-cd $(DESTDIR)$(pkgdatadir) && rm -f $(VL_INST_INC_SRCDIR_FILES)
@@ -301,65 +370,78 @@ uninstall:
 	-rmdir $(DESTDIR)$(pkgdatadir)/examples/cmake_tracing_c
 	-rmdir $(DESTDIR)$(pkgdatadir)/examples/cmake_tracing_sc
 	-rmdir $(DESTDIR)$(pkgdatadir)/examples/cmake_protect_lib
-	-rmdir $(DESTDIR)$(pkgdatadir)/examples/xml_py
+	-rmdir $(DESTDIR)$(pkgdatadir)/examples/json_py
 	-rmdir $(DESTDIR)$(pkgdatadir)/examples
 	-rmdir $(DESTDIR)$(pkgdatadir)
 	-rmdir $(DESTDIR)$(pkgconfigdir)
 
 install: all_nomsg install-all
-install-all: installbin installman installdata install-msg
+install-all: installbin installredirect installman installdata install-msg
 
 install-here: installman info
 
-# 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)
-CHECK_H = $(wildcard \
-	$(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)/src/obj_dbg -I$(srcdir)/src
+install-msg:
+	@echo
+	@echo "Installed binaries to $(DESTDIR)$(bindir)/verilator"
+	@echo "Installed man to $(DESTDIR)$(mandir)/man1"
+	@echo "Installed examples to $(DESTDIR)$(pkgdatadir)/examples"
+	@echo
+	@echo "For documentation see 'man verilator' or 'verilator --help'"
+	@echo "For forums and to report bugs see https://verilator.org"
+	@echo
 
-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)
+######################################################################
+# Format/Lint
+
+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 )
+CHECK_YL = $(wildcard \
+  $(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_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
@@ -378,74 +460,134 @@ analyzer-include:
 	-rm -rf examples/*/obj*
 	scan-build $(MAKE) -k examples
 
-format: clang-format yapf format-pl-exec
+format:
+	$(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
 
-clang-format:
-	@$(CLANGFORMAT) --version | egrep 14.0 > /dev/null \
-		|| echo "*** You are not using clang-format-14, indents may differ from master's ***"
+format-c clang-format:
+	$(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)
 
-PY_PROGRAMS = \
-	bin/verilator_ccache_report \
-	bin/verilator_difftree \
-	bin/verilator_gantt \
-	bin/verilator_includer \
-	bin/verilator_profcfunc \
-	examples/xml_py/vl_file_copy \
-	examples/xml_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 \
-	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 \
+YAMLFIX = YAMLFIX_WHITELINES=1 YAMLFIX_LINE_LENGTH=200 YAMLFIX_preserve_quotes=true yamlfix
 
+yamlfix:
+	$(YAMLFIX) .
+
+# CMake files
+CMAKE_FILES = \
+  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/flexfix \
+  src/vlcovgen \
+  src/.gdbinit.py \
+  test_regress/*.py \
+  test_regress/t/*.pf \
+  nodist/clang_check_attributes \
+  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 \
+  $(PY_PROGRAMS) \
+  test_regress/t/*.py \
+
+# Python files, test_regress tests
+PY_TEST_FILES = test_regress/t/*.py
 
 YAPF = yapf3
-YAPF_FLAGS = -i
+YAPF_FLAGS = -i --parallel
 
-yapf:
+format-py yapf:
+	$(YAPF) --version
 	$(YAPF) $(YAPF_FLAGS) $(PY_FILES)
 
+GERSEMI = gersemi
+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
+
+MYPY = mypy
+MYPY_FLAGS = --strict --no-error-summary
+
 PYLINT = pylint
-PYLINT_FLAGS = --score=n --disable=R0801
+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
 
 RUFF = ruff
 RUFF_FLAGS = check --ignore=E402,E501,E701
 
+# "make -k" so can see all tool result errors
 lint-py:
-	-$(PYLINT) $(PYLINT_FLAGS) $(PY_PROGRAMS)
-	-$(RUFF) $(RUFF_FLAGS) $(PY_PROGRAMS)
+	$(MAKE) -k lint-py-mypy lint-py-mypy-none lint-py-pylint lint-py-pylint-tests lint-py-ruff
 
-format-pl-exec:
-	-chmod a+x test_regress/t/*.pl
+lint-py-mypy:
+	for filename in `fgrep -l '# mypy' $(PY_PROGRAMS)`; do \
+		echo "$(MYPY) $(MYPY_FLAGS) $$filename" ; \
+		$(MYPY) $(MYPY_FLAGS) $$filename ; \
+	done
 
-install-msg:
-	@echo
-	@echo "Installed binaries to $(DESTDIR)$(bindir)/verilator"
-	@echo "Installed man to $(DESTDIR)$(mandir)/man1"
-	@echo "Installed examples to $(DESTDIR)$(pkgdatadir)/examples"
-	@echo
-	@echo "For documentation see 'man verilator' or 'verilator --help'"
-	@echo "For forums and to report bugs see https://verilator.org"
-	@echo
+lint-py-mypy-none:
+	@echo "mypy not checking: " `fgrep -L '# mypy' $(PY_PROGRAMS)`
+
+lint-py-pylint:
+	$(PYLINT) $(PYLINT_FLAGS) $(PY_PROGRAMS)
+
+lint-py-pylint-tests:
+	$(PYLINT) $(PYLINT_TEST_FLAGS) $(PY_TEST_FILES) | $(PYTHON3) nodist/lint_py_test_filter
+
+lint-py-ruff:
+	$(RUFF) $(RUFF_FLAGS) $(PY_PROGRAMS)
+
+format-exec:
+	-chmod a+x test_regress/t/*.py
+
+######################################################################
+# Configure
 
 IN_WILD := ${srcdir}/*.in ${srcdir}/*/*.in
 
@@ -466,6 +608,152 @@ else
 	autoconf
 endif
 
+######################################################################
+# Coverage collection and reporting
+
+COVERAGE_DIR := obj_coverage
+
+ifeq ($(CFG_WITH_DEV_GCOV),yes)
+
+# Figure out base and head refs for coverage report
+COVERAGE_REF_BASE := $(if $(COVERAGE_BASE),$(shell git rev-parse --short $(COVERAGE_BASE)))
+COVERAGE_REF_HEAD := $(shell git rev-parse --short HEAD)
+override undefine COVERAGE_BASE # Use the above variabels instead
+
+# 'fastcov' setup
+FASTCOV := nodist/fastcov.py
+FASTCOV_OPT := -j $(shell nproc)
+FASTCOV_OPT += --lcov
+FASTCOV_OPT += --process-gcno
+FASTCOV_OPT += --branch-coverage
+FASTCOV_OPT += --dump-statistic
+# Files matching the following glob patterns will be excluded from coverage
+FASTCOV_OPT += --exclude-glob
+FASTCOV_OPT += '/usr/*'
+FASTCOV_OPT += '*examples/*'
+FASTCOV_OPT += '*include/gtkwave/*'
+FASTCOV_OPT += '*src/obj_dbg/*'
+FASTCOV_OPT += '*src/obj_opt/*.yy.cpp'
+FASTCOV_OPT += '*src/obj_opt/V3Ast*'
+FASTCOV_OPT += '*src/obj_opt/V3Dfg*'
+FASTCOV_OPT += '*src/obj_opt/V3ParseBison.c'
+FASTCOV_OPT += '*test_regress/*'
+# Lines *containing* these substrings will be excluded from *all* coverage
+FASTCOV_OPT += --custom-exclusion-marker
+FASTCOV_OPT += ASTGEN_MEMBERS
+FASTCOV_OPT += ERROR_RSVD_WORD
+FASTCOV_OPT += LCOV_EXCL_LINE
+FASTCOV_OPT += V3ERROR_NA
+FASTCOV_OPT += VL_DEFINE_DEBUG_FUNCTIONS
+FASTCOV_OPT += VL_FATAL
+FASTCOV_OPT += VL_RTTI_IMPL
+FASTCOV_OPT += VL_UNREACHABLE
+FASTCOV_OPT += v3fatalSrc
+# Lines *starting* with these substrings will be ecluded from *branch* coverage
+FASTCOV_OPT += --exclude-br-lines-starting-with
+FASTCOV_OPT += BROKEN_BASE_RTN
+FASTCOV_OPT += BROKEN_RTN
+FASTCOV_OPT += NUM_ASSERT
+FASTCOV_OPT += SELF_CHECK
+FASTCOV_OPT += UASSERT
+FASTCOV_OPT += UINFO
+FASTCOV_OPT += assert
+FASTCOV_OPT += 'if (VL_UNCOVERABLE'
+FASTCOV_OPT += '} else if (VL_UNCOVERABLE'
+
+# 'genhtml' setup
+GENHTML := genhtml
+GENHTML_OPT := -j $(shell nproc)
+GENHTML_OPT += --branch-coverage
+GENHTML_OPT += --demangle-cpp
+GENHTML_OPT += --missed
+GENHTML_OPT += --rc branch_coverage=1
+GENHTML_OPT += --rc genhtml_hi_limit=100
+GENHTML_OPT += --ignore-errors negative
+ifeq ($(COVERAGE_REF_BASE),)
+GENHTML_OPT += --header-title "Code coverage for Verilator $(shell git describe --dirty)"
+else
+GENHTML_OPT += --header-title "Patch coverage for Verilator $(COVERAGE_REF_BASE)..$(COVERAGE_REF_HEAD)$(if $(shell git status --porcelain),-dirty)"
+endif
+GENHTML_OPT += --flat
+GENHTML_OPT += --precision 2
+GENHTML_OPT += --legend
+GENHTML_OPT += --show-proportion
+GENHTML_OPT += --filter brace,blank,range
+
+# There are loads (~20k combined), but using this seems fine on modern hardware
+GCNO_FILES = $(shell find . -name '*.gcno')
+GCDA_FILES = $(shell find . -name '*.gcda')
+
+# Combine all .gcda coverage date files into lcov .info file
+$(COVERAGE_DIR)/verilator.info: $(GCNO_FILES) $(GCDA_FILES)
+	@echo "####################################################################"
+	@echo "# fastcov: combining all .gcda files into lcov .info"
+	@echo "####################################################################"
+	@mkdir -p $(COVERAGE_DIR)
+	/usr/bin/time -f "That took %E" \
+	$(FASTCOV) $(FASTCOV_OPT) --output $@
+
+# Filter combined .info file for patch coverage
+$(COVERAGE_DIR)/verilator-patch.info: $(COVERAGE_DIR)/verilator.info
+	@echo "####################################################################"
+	@echo "# fastcov: Filtering for patch coverage"
+	@echo "####################################################################"
+	rm -f $(COVERAGE_DIR)/empty-patch
+	git diff $(COVERAGE_REF_BASE) -- include src > $(COVERAGE_DIR)/filter.patch
+	[ -s $(COVERAGE_DIR)/filter.patch ]] || touch $(COVERAGE_DIR)/empty-patch
+	$(FASTCOV) -C $^ --lcov -o $@ --diff-filter $(COVERAGE_DIR)/filter.patch
+
+# Build coverage report
+$(COVERAGE_DIR)/report/index.html: $(COVERAGE_DIR)/verilator$(if $(COVERAGE_REF_BASE),-patch).info
+	@echo "####################################################################"
+	@echo "# genhtml: Generating coverage report"
+	@echo "####################################################################"
+	@rm -rf $(COVERAGE_DIR)/report
+	[ -f $(COVERAGE_DIR)/empty-patch ]] || /usr/bin/time -f "That took %E" \
+	$(GENHTML) $(GENHTML_OPT) --output-directory $(COVERAGE_DIR)/report $^ || true
+	@# Uncommitted changes not tracked, force rebuild on next run if patch coverage
+	@$(if $(COVERAGE_REF_BASE),mv $(COVERAGE_DIR)/verilator-patch.info $(COVERAGE_DIR)/verilator-patch-last.info)
+
+# Convenience targets
+.PHONY: coverage-combine
+coverage-combine: $(COVERAGE_DIR)/verilator.info
+
+# Via recursive make, so the message is always printed
+.PHONY: coverage-report
+coverage-report:
+	@$(MAKE) --no-print-directory $(COVERAGE_DIR)/report/index.html || true
+	@if [ -f $(COVERAGE_DIR)/report/index.html ]; then \
+		echo "####################################################################"; \
+		echo "# Coverage report is at: $(COVERAGE_DIR)/report/index.html"; \
+		echo "# Use 'make coverage-view' to open it in your default browser"; \
+		echo "####################################################################"; \
+	elif [ -f $(COVERAGE_DIR)/empty-patch ]; then \
+		echo "####################################################################"; \
+		echo "# Patch is empty"; \
+		echo "####################################################################"; \
+	else \
+		echo "####################################################################"; \
+		echo "# Failed to create coverage report. Maybe no data, or error?"; \
+		echo "####################################################################"; \
+		false; \
+	fi
+
+# Open covarage report in default web browser
+.PHONY: coverage-view
+coverage-view: coverage-report
+	@test -f $(COVERAGE_DIR)/report/index.html && open $(COVERAGE_DIR)/report/index.html || true
+
+# Deletes all coverage data files (.gcda)
+.PHONY: coverage-zero
+coverage-zero: # 'rm $(GCDA_FILES)' might fail with too many args
+	$(FASTCOV) --zerocounters
+
+endif
+
+######################################################################
+# Clean
+
 maintainer-clean::
 	@echo "This command is intended for maintainers to use;"
 	@echo "rebuilding the deleted files requires autoconf."
@@ -473,8 +761,8 @@ maintainer-clean::
 
 clean mostlyclean distclean maintainer-clean maintainer-copy::
 	for dir in $(SUBDIRS); do \
-	  echo making $@ in $$dir ; \
-	  $(MAKE) -C $$dir $@ ; \
+		echo making $@ in $$dir ; \
+		$(MAKE) -C $$dir $@ ; \
 	done
 
 clean mostlyclean distclean maintainer-clean::
@@ -485,8 +773,10 @@ 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 $(COVERAGE_DIR)
 	rm -rf verilator.txt
 
 distclean maintainer-clean::
@@ -496,17 +786,6 @@ distclean maintainer-clean::
 	rm -f bin/verilator_bin* bin/verilator_coverage_bin*
 	rm -f include/verilated.mk include/verilated_config.h
 
-TAGFILES=${srcdir}/*/*.cpp ${srcdir}/*/*.h ${srcdir}/*/*.in \
-	${srcdir}/*.in ${srcdir}/*.pod
-
-TAGS: $(TAGFILES)
-	etags $(TAGFILES)
-
-.PHONY: doxygen
-
-doxygen:
-	$(MAKE) -C docs doxygen
-
 ######################################################################
 # Distributions
 

README.rst

@@ -1,22 +1,22 @@
 .. Github doesn't render images unless absolute URL
 .. Do not know of a conditional tag, "only: github" nor "github display" works
 
-.. image:: https://img.shields.io/badge/Website-Verilator.org-181717.svg
+|badge1| |badge2| |badge3| |badge4| |badge5| |badge7| |badge8|
+
+.. |badge1| image:: https://img.shields.io/badge/Website-Verilator.org-181717.svg
     :target: https://verilator.org
-.. image:: https://img.shields.io/badge/License-LGPL%20v3-blue.svg
+.. |badge2| image:: https://img.shields.io/badge/License-LGPL%20v3-blue.svg
     :target: https://www.gnu.org/licenses/lgpl-3.0
-.. image:: https://img.shields.io/badge/License-Artistic%202.0-0298c3.svg
+.. |badge3| image:: https://img.shields.io/badge/License-Artistic%202.0-0298c3.svg
     :target: https://opensource.org/licenses/Artistic-2.0
-.. image:: https://repology.org/badge/tiny-repos/verilator.svg?header=distro%20packages
+.. |badge4| image:: https://repology.org/badge/tiny-repos/verilator.svg?header=distro%20packages
     :target: https://repology.org/project/verilator/versions
-.. image:: https://img.shields.io/docker/pulls/verilator/verilator
+.. |badge5| image:: https://img.shields.io/docker/pulls/verilator/verilator
     :target: https://hub.docker.com/r/verilator/verilator
-.. image:: https://api.codacy.com/project/badge/Grade/fa78caa433c84a4ab9049c43e9debc6f
-    :target: https://www.codacy.com/gh/verilator/verilator
-.. image:: https://codecov.io/gh/verilator/verilator/branch/master/graph/badge.svg
-    :target: https://codecov.io/gh/verilator/verilator
-.. image:: https://github.com/verilator/verilator/workflows/build/badge.svg
+.. |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
@@ -37,6 +37,7 @@ Welcome to Verilator
    * - **Widely Used**
         * Wide industry and academic deployment
         * Out-of-the-box support from Arm and RISC-V vendor IP
+        * Over 700 contributors
      - |verilator usage|
    * - |verilator community|
      - **Community Driven & Openly Licensed**
@@ -66,9 +67,9 @@ executable performs the design simulation. Verilator also supports linking
 Verilated generated libraries, optionally encrypted, into other simulators.
 
 Verilator may not be the best choice if you are expecting a full-featured
-replacement for a closed-source Verilog simulator, needs SDF annotation,
+replacement for a closed-source Verilog simulator, need SDF annotation,
 mixed-signal simulation, or are doing a quick class project (we recommend
-`Icarus Verilog`_ for classwork.)  However, if you are looking for a path
+`Icarus Verilog`_ for classwork).  However, if you are looking for a path
 to migrate SystemVerilog to C++/SystemC, or want high-speed simulation of
 designs, Verilator is the tool for you.
 
@@ -80,17 +81,16 @@ Verilator does not directly translate Verilog HDL to C++ or SystemC. Rather,
 Verilator compiles your code into a much faster optimized and optionally
 thread-partitioned model, which is in turn wrapped inside a C++/SystemC
 module. The results are a compiled Verilog model that executes even on a
-single-thread over 10x faster than standalone SystemC, and on a single
+single thread over 10x faster than standalone SystemC, and on a single
 thread is about 100 times faster than interpreted Verilog simulators such
 as `Icarus Verilog`_. Another 2-10x speedup might be gained from
 multithreading (yielding 200-1000x total over interpreted simulators).
 
-Verilator has typically similar or better performance versus the
-closed-source Verilog simulators (e.g., Carbon Design Systems Carbonator,
-Modelsim/Questa, Cadence Incisive/NC-Verilog, Synopsys VCS, VTOC, and
-Pragmatic CVer/CVC). But, Verilator is open-sourced, so you can spend on
-computes rather than licenses. Thus, Verilator gives you the best
-simulation cycles/dollar.
+Verilator has typically similar or better performance versus closed-source
+Verilog simulators (e.g., Aldec Riviera-Pro, Cadence Incisive/NC-Verilog,
+Mentor ModelSim/Questa, Synopsys VCS, VTOC, and Pragmatic CVer/CVC). But,
+Verilator is open-sourced, so you can spend on computes rather than
+licenses. Thus, Verilator gives you the best simulation cycles/dollar.
 
 
 Installation & Documentation
@@ -132,17 +132,20 @@ 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.
 
+- `Surfer <https://surfer-project.org/>`_ - Web or offline waveform viewer
+  for Verilator traces.
+
 
 Open License
 ============
 
-Verilator is Copyright 2003-2023 by Wilson Snyder. (Report bugs to
+Verilator is Copyright 2003-2025 by Wilson Snyder. (Report bugs to
 `Verilator Issues <https://verilator.org/issues>`_.)
 
 Verilator is free software; you can redistribute it and/or modify it under
@@ -150,7 +153,7 @@ the terms of either the GNU Lesser General Public License Version 3 or the
 Perl Artistic License Version 2.0. See the documentation for more details.
 
 .. _CHIPS Alliance: https://chipsalliance.org
-.. _Icarus Verilog: http://iverilog.icarus.com
+.. _Icarus Verilog: https://steveicarus.github.io/iverilog
 .. _Linux Foundation: https://www.linuxfoundation.org
 .. |Logo| image:: https://www.veripool.org/img/verilator_256_200_min.png
 .. |verilator multithreaded performance| image:: https://www.veripool.org/img/verilator_multithreaded_performance_bg-min.png

bin/redirect

@@ -0,0 +1,22 @@
+#!/usr/bin/env perl
+######################################################################
+#
+# Copyright 2003-2025 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+#
+######################################################################
+
+require 5.006_001;
+use warnings;
+use FindBin qw($RealBin $RealScript);
+use strict;
+
+my $relpath = RELPATH;  # Substituted during Verilator 'make install'
+
+unshift @ARGV, $RealScript;
+
+exec { "$RealBin/$relpath/$RealScript" } @ARGV;
+die "%Error: Exec failed,";

bin/verilator

@@ -1,7 +1,7 @@
 #!/usr/bin/env perl
 ######################################################################
 #
-# Copyright 2003-2023 by Wilson Snyder. This program is free software; you
+# Copyright 2003-2025 by Wilson Snyder. This program is free software; you
 # can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
@@ -15,6 +15,7 @@ use Getopt::Long;
 use FindBin qw($RealBin $RealScript);
 use IO::File;
 use Pod::Usage;
+use Cwd qw(realpath);
 
 use strict;
 use vars qw($Debug @Opt_Verilator_Sw);
@@ -27,11 +28,13 @@ autoflush STDOUT 1;
 autoflush STDERR 1;
 
 $Debug = 0;
+my $opt_aslr;
 my $opt_gdb;
 my $opt_rr;
 my $opt_gdbbt;
 my $opt_quiet_exit;
 my $opt_unlimited_stack = 1;
+my $opt_valgrind;
 
 # No arguments can't do anything useful.  Give help
 if ($#ARGV < 0) {
@@ -54,17 +57,34 @@ if (! GetOptions(
           "debug"            => \&debug,
           # "version!"       => \&version,   # Also passthru'ed
           # Switches
+          "aslr!"            => \$opt_aslr,
           "gdb!"             => \$opt_gdb,
           "gdbbt!"           => \$opt_gdbbt,
+          "quiet!"           => \$opt_quiet_exit,  # As -quiet implies -quiet-exit
           "quiet-exit!"      => \$opt_quiet_exit,
           "rr!"              => \$opt_rr,
           "unlimited-stack!" => \$opt_unlimited_stack,
+          "valgrind!"        => \$opt_valgrind,
           # Additional parameters
           "<>"               => sub {},      # Ignored
     )) {
     pod2usage(-exitstatus => 2, -verbose => 0);
 }
 
+# WARNING: $verilator_pkgdatadir_relpath is substituted during Verilator 'make install'
+my $verilator_pkgdatadir_relpath = "..";
+my $verilator_root = realpath("$RealBin/$verilator_pkgdatadir_relpath");
+if (defined $ENV{VERILATOR_ROOT}) {
+    if ((!-d $ENV{VERILATOR_ROOT}) || $verilator_root ne realpath($ENV{VERILATOR_ROOT})) {
+        warn "%Error: verilator: VERILATOR_ROOT is set to inconsistent path. Suggest leaving it unset.\n";
+        warn "%Error: VERILATOR_ROOT=$ENV{VERILATOR_ROOT}\n";
+        exit 1;
+    }
+} else {
+    print "export VERILATOR_ROOT='$verilator_root'\n" if $Debug;
+    $ENV{VERILATOR_ROOT} = $verilator_root;
+}
+
 if ($opt_gdbbt && !gdb_works()) {
     warn "-Info: --gdbbt ignored: gdb doesn't seem to be working\n" if $Debug;
     $opt_gdbbt = 0;
@@ -79,7 +99,7 @@ my @quoted_sw = map { sh_escape($_) } @Opt_Verilator_Sw;
 if ($opt_gdb) {
     # Generic GDB interactive
     run (ulimit_stack_unlimited()
-         . aslr_off()
+         . aslr(0)
          . ($ENV{VERILATOR_GDB} || "gdb")
          . " " . verilator_bin()
          # Note, uncomment to set breakpoints before running:
@@ -96,28 +116,40 @@ if ($opt_gdb) {
 } elsif ($opt_rr) {
     # Record with rr
     run (ulimit_stack_unlimited()
-         . aslr_off()
+         . aslr(0)
          . "rr record " . verilator_bin()
          . " " . join(' ', @quoted_sw));
 } elsif ($opt_gdbbt && $Debug) {
     # Run under GDB to get gdbbt
     run (ulimit_stack_unlimited()
-         . aslr_off()
+         . aslr(0)
          . "gdb"
          . " " . verilator_bin()
          . " --batch --quiet --return-child-result"
          . " -ex \"run " . join(' ', @quoted_sw)."\""
          . " -ex 'set width 0'"
          . " -ex 'bt' -ex 'quit'");
+} elsif ($opt_valgrind) {
+    # Run under valgrind
+    my $valgrind_bin = ($ENV{VERILATOR_VALGRIND} || "valgrind --error-exitcode=1 --max-stackframe=2815880"
+        # 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
+        );
+
+    run (ulimit_stack_unlimited()
+         . aslr(0)
+         . $valgrind_bin
+         . " " . verilator_bin()
+         . " " . join(' ', @quoted_sw));
 } elsif ($Debug) {
     # Debug
     run(ulimit_stack_unlimited()
-        . aslr_off()
+        . aslr(0)
         . verilator_bin()
         . " " . join(' ', @quoted_sw));
 } else {
     # Normal, non gdb
-    run(ulimit_stack_unlimited() . verilator_bin() . " " . join(' ', @quoted_sw));
+    run(ulimit_stack_unlimited() . aslr(1) . verilator_bin() . " " . join(' ', @quoted_sw));
 }
 
 #----------------------------------------------------------------------
@@ -137,30 +169,13 @@ sub debug {
 # Builds
 
 sub verilator_bin {
-    my $bin = "";
-    # Use VERILATOR_ROOT if defined, else assume verilator_bin is in the search path
     my $basename = ($ENV{VERILATOR_BIN}
                     || ($Debug ? "verilator_bin_dbg" : "verilator_bin"));
-    if (defined($ENV{VERILATOR_ROOT})) {
-        my $dir = $ENV{VERILATOR_ROOT};
-        if (-x "$dir/bin/$basename"
-            || -x "$dir/bin/$basename.exe") {  # From a "make install" into VERILATOR_ROOT
-            $bin = "$dir/bin/$basename";
-        } else {
-            $bin = "$dir/$basename";  # From pointing to kit directory
-        }
+    if (-x "$RealBin/$basename" || -x "$RealBin/$basename.exe") {
+        return "$RealBin/$basename";
     } else {
-        if (-x "$RealBin/$basename"
-            || -x "$RealBin/$basename.exe") {
-            $bin = "$RealBin/$basename";  # From path/to/verilator with verilator_bin installed
-        } else {
-            $bin = $basename;  # Find in PATH
-        }
-        # Note we don't look under bin/$basename which would be right if running
-        # in the kit dir. Running that would likely break, since
-        # VERILATOR_ROOT wouldn't be set and Verilator won't find internal files.
+        return $basename;  # Find in PATH
     }
-    return $bin;
 }
 
 #######################################################################
@@ -179,21 +194,37 @@ sub gdb_works {
     return $status == 0;
 }
 
-sub aslr_off {
-    my $ok = `setarch --addr-no-randomize echo ok 2>/dev/null` || "";
-    if ($ok =~ /ok/) {
-        return "setarch --addr-no-randomize ";
-    } else {
-        return "";
+sub aslr {
+    my $want_on = shift;
+    $want_on = $opt_aslr if defined $opt_aslr;
+    if (!$want_on) {
+        my $ok = `setarch --addr-no-randomize echo ok 2>/dev/null` || "";
+        if ($ok =~ /ok/) {
+            return "setarch --addr-no-randomize ";
+        }
     }
+    return "";
 }
 
 sub ulimit_stack_unlimited {
     return "" if !$opt_unlimited_stack;
-    system("ulimit -s unlimited 2>/dev/null");
+    my $limit = "unlimited";
+    # AddressSanitizer doesn't work with 'ulimit -s unlimted'
+    if (`${\(verilator_bin())} --get-supported DEV_ASAN` eq "1\n") {
+        # Use host 'physical memory / #cores / 8' instead
+        open(my $fh, "<", "/proc/meminfo") || die "Can't read host memory for asan";
+        while (<$fh>) {
+            if (m/MemTotal:\s+(\d+)\s+kB/) {
+                $limit = int(int($1)/`nproc`/8);
+                last;
+            }
+        }
+        close($fh);
+    }
+    system("ulimit -s $limit 2>/dev/null");
     my $status = $?;
     if ($status == 0) {
-        return "ulimit -s unlimited 2>/dev/null; exec ";
+        return "ulimit -s $limit 2>/dev/null; exec ";
     } else {
         return "";
     }
@@ -214,17 +245,18 @@ sub run {
             warn "%Error: export VERILATOR_ROOT=" . ($ENV{VERILATOR_ROOT} || "") . "\n";
             warn "%Error: $command\n";
         }
-        if ($status & 127) {
-            if (($status & 127) == 4  # SIGILL
-                || ($status & 127) == 8  # SIGFPA
-                || ($status & 127) == 11) {  # SIGSEGV
+        my $signal = ($status & 127);
+        if ($signal) {
+            if ($signal == 4  # SIGILL
+                || $signal == 8  # SIGFPA
+                || $signal == 11) {  # SIGSEGV
                 warn "%Error: Verilator internal fault, sorry. "
                     . "Suggest trying --debug --gdbbt\n" if !$Debug;
-            } elsif (($status & 127) == 6) {  # SIGABRT
+            } elsif ($signal == 6) {  # SIGABRT
                 warn "%Error: Verilator aborted. "
                     . "Suggest trying --debug --gdbbt\n" if !$Debug;
             } else {
-                warn "%Error: Verilator threw signal $status. "
+                warn "%Error: Verilator threw signal $signal. "
                     . "Suggest trying --debug --gdbbt\n" if !$Debug;
             }
         }
@@ -232,8 +264,8 @@ sub run {
             warn "%Error: Command Failed $command\n";
         }
         exit $! if $!;  # errno
-        exit $? >> 8 if $? >> 8;  # child exit status
-        exit 255;  # last resort
+        exit $? >> 8 if $? >> 8;  # pass along child exit code
+        exit 128 + $signal;  # last resort
     }
 }
 
@@ -243,7 +275,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;
 }
 
@@ -256,8 +288,7 @@ __END__
 
 =head1 NAME
 
-Verilator - Translate and simulate SystemVerilog code using C++/SystemC
-
+Verilator - Lint, compile and simulate SystemVerilog code using C++/SystemC
 
 =head1 SYNOPSIS
 
@@ -298,7 +329,10 @@ detailed descriptions of these arguments.
      +1800-2009ext+<ext>        Use SystemVerilog 2009 with file extension <ext>
      +1800-2012ext+<ext>        Use SystemVerilog 2012 with file extension <ext>
      +1800-2017ext+<ext>        Use SystemVerilog 2017 with file extension <ext>
-    --assert                    Enable all assertions
+     +1800-2023ext+<ext>        Use SystemVerilog 2023 with file extension <ext>
+    --no-aslr                   Disable address space layout randomization
+    --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
@@ -307,13 +341,13 @@ detailed descriptions of these arguments.
     --build-dep-bin <filename>  Override build dependency Verilator binary
     --build-jobs <jobs>         Parallelism for --build
     --cc                        Create C++ output
-    --cdc                       Clock domain crossing analysis
      -CFLAGS <flags>            C++ compiler arguments for makefile
-    --clk <signal-name>         Mark specified signal as clock
-    --no-clk <signal-name>      Prevent marking specified signal as clock
     --compiler <compiler-name>  Tune for specified C++ compiler
+    --compiler-include          Include additional header in the precompiled one
     --converge-limit <loops>    Tune convergence settle time
     --coverage                  Enable all coverage
+    --coverage-expr             Enable expression coverage
+    --coverage-expr-max <value>     Maximum permutations allowed for an expression
     --coverage-line             Enable line coverage
     --coverage-max-width <width>   Maximum array depth for coverage
     --coverage-toggle           Enable toggle coverage
@@ -325,21 +359,29 @@ 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
-    --no-decoration             Disable comments and symbol decorations
+    --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
+    --dump-inputs               Enable dumping preprocessed input files
     --dump-tree                 Enable dumping Ast .tree files
     --dump-tree-addrids         Use short identifiers instead of addresses
-    --dump-<srcfile>            Enable dumping everything in source file
+    --dump-tree-dot             Enable dumping Ast .tree.dot debug files
+    --dump-tree-json            Enable dumping Ast .tree.json files and .tree.meta.json 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-<srcfile> <level>   Enable dumping everything in source file at level
+    --dumpi-tree-json <level>   Enable dumping Ast .tree.json files 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
     --exe                       Link to create executable
     --expand-limit <value>      Set expand optimization limit
@@ -347,55 +389,75 @@ detailed descriptions of these arguments.
      -f <file>                  Parse arguments from a file
      -FI <file>                 Force include of a file
     --flatten                   Force inlining of all modules, tasks and functions
+    --future0 <option>          Ignore an option for compatibility
+    --future1 <option>          Ignore an option with argument for compatibility
      -fno-<optimization>        Disable internal optimization stage
      -G<name>=<value>           Overwrite top-level parameter
     --gate-stmts <value>        Tune gate optimizer depth
     --gdb                       Run Verilator under GDB interactively
     --gdbbt                     Run Verilator under GDB for backtrace
     --generate-key              Create random key for --protect-key
-    --getenv <var>              Get environment variable with defaults
     --get-supported <feature>   Get if feature is supported
-    --help                      Display this help
+    --getenv <var>              Get environment variable with defaults
+    --help                      Show this help
     --hierarchical              Enable hierarchical Verilation
+    --hierarchical-block <block>  Internal use only for --hierarchical
+    --hierarchical-child <block>  Internal use only for --hierarchical
+    --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
     --inline-mult <value>       Tune module inlining
     --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 addresses/paths in .tree.json
+    --json-only                 Create JSON parser output (.tree.json and .meta.json)
+    --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
     --lib-create <name>         Create a DPI library
      +libext+<ext>+[ext]...     Extensions for finding modules
+     +librescan                 Ignored for compatibility
     --lint-only                 Lint, but do not make output
-    --make <build-tool>         Generate scripts for specified build tool
-     -MAKEFLAGS <flags>         Arguments to pass to make during --build
+    --localize-max-size <value>  Tune localize optimization variable size
     --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
+     -O1                        Default optimizations
+     -O2                        Stronger optimizations
      -O3                        High-performance optimizations
      -O<optimization-letter>    Selectable optimizations
-     -o <executable>            Name of final executable
-    --no-order-clock-delay      Disable ordering clock enable assignments
+    --output-groups <numfiles>  Group .cpp files into larger ones
     --output-split <statements>          Split .cpp files into pieces
     --output-split-cfuncs <statements>   Split model functions
     --output-split-ctrace <statements>   Split tracing functions
      -P                         Disable line numbers and blanks with -E
     --pins-bv <bits>            Specify types for top-level ports
+    --pins-inout-enables        Specify that __en and __out signals be created for inouts
     --pins-sc-biguint           Specify types for top-level ports
     --pins-sc-uint              Specify types for top-level ports
+    --pins-sc-uint-bool         Specify types for top-level ports
     --pins-uint8                Specify types for top-level ports
     --no-pins64                 Don't use uint64_t's for 33-64 bit sigs
     --pipe-filter <command>     Filter all input through a script
-    --pp-comments               Show preprocessor comments with -E
     --prefix <topname>          Name of top-level class
+    --preproc-comments          Include preprocessor comments in the output with -E
+    --preproc-defines           Include preprocessor defines in the output with -E
+    --preproc-resolve           Include all found modules in the output with -E
+    --preproc-token-limit       Maximum tokens on a line allowed by preprocessor
     --private                   Debugging; see docs
     --prof-c                    Compile C++ code with profiling
     --prof-cfuncs               Name functions for profiling
@@ -404,43 +466,54 @@ detailed descriptions of these arguments.
     --protect-ids               Hash identifier names for obscurity
     --protect-key <key>         Key for symbol protection
     --protect-lib <name>        Create a DPI protected library
-    --public                    Debugging; see docs
-    --public-params             Mark all parameters as public_flat
+    --public                    Mark signals as public; see docs
+    --public-depth <level>      Mark public to specified module depth
     --public-flat-rw            Mark all variables, etc as public_flat_rw
+    --public-ignore             Ignore all public comment markings
+    --public-params             Mark all parameters as public_flat
      -pvalue+<name>=<value>     Overwrite toplevel parameter
+    --quiet                     Minimize additional printing
     --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
     --savable                   Enable model save-restore
     --sc                        Create SystemC output
     --no-skip-identical         Disable skipping identical output
     --stats                     Create statistics file
     --stats-vars                Provide statistics on variables
-    --no-std                    Prevent parsing standard library
+    --no-std                    Prevent loading standard files
+    --no-std-package            Prevent parsing standard package
+    --no-std-waiver             Prevent parsing standard lint waivers
+    --no-stop-fail              Do not call $stop when assertion fails
     --structs-packed            Convert all unpacked structures to packed structures
      -sv                        Enable SystemVerilog parsing
-     +systemverilogext+<ext>    Synonym for +1800-2017ext+<ext>
+     +systemverilogext+<ext>    Synonym for +1800-2023ext+<ext>
     --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 bit width for tracing
-    --trace-max-width <width>   Maximum array depth for tracing
+    --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
@@ -448,13 +521,15 @@ detailed descriptions of these arguments.
     --unused-regexp <regexp>    Tune UNUSED lint signals
      -V                         Verbose version and config
      -v <filename>              Verilog library
-    --verilate-jobs             Job threads for Verilation stage
+    --valgrind                  Run Verilator under valgrind
     --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                   Displays program version and exits
+    --version                   Show program version and exits
     --vpi                       Enable VPI compiles
-    --waiver-output <filename>  Create a waiver file based on the linter warnings
+    --waiver-multiline          Create multiline --match for waivers
+    --waiver-output <filename>  Create a waiver file based on linter warnings
      -Wall                      Enable all style warnings
      -Werror-<message>          Convert warnings to errors
      -Wfuture-<message>         Disable unknown message warnings
@@ -463,6 +538,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
@@ -481,26 +557,28 @@ description of these arguments.
 
 =for VL_SPHINX_EXTRACT "_build/gen/args_verilated.rst"
 
-     +verilator+debug                  Enable debugging
-     +verilator+debugi+<value>         Enable debugging at a level
-     +verilator+error+limit+<value>    Set error limit
-     +verilator+help                   Display help
-     +verilator+noassert               Disable assert checking
+     +verilator+coverage+file+<filename>   Set coverage output filename
+     +verilator+debug                      Enable debugging
+     +verilator+debugi+<value>             Enable debugging at a level
+     +verilator+error+limit+<value>        Set error limit
+     +verilator+help                       Show help
+     +verilator+noassert                   Disable assert checking
      +verilator+prof+exec+file+<filename>  Set execution profile filename
      +verilator+prof+exec+start+<value>    Set execution profile starting point
      +verilator+prof+exec+window+<value>   Set execution profile duration
      +verilator+prof+vlt+file+<filename>   Set PGO profile filename
-     +verilator+rand+reset+<value>     Set random reset technique
-     +verilator+seed+<value>           Set random seed
-     +verilator+V                      Verbose version and config
-     +verilator+version                Show version and exit
+     +verilator+quiet                      Minimize additional printing
+     +verilator+rand+reset+<value>         Set random reset technique
+     +verilator+seed+<value>               Set random seed
+     +verilator+V                          Show verbose version and config
+     +verilator+version                    Show version and exit
 
 
 =head1 DISTRIBUTION
 
 The latest version is available from L<https://verilator.org>.
 
-Copyright 2003-2023 by Wilson Snyder. This program is free software; you can
+Copyright 2003-2025 by Wilson Snyder. This program is free software; you can
 redistribute it and/or modify the Verilator internals under the terms of
 either the GNU Lesser General Public License Version 3 or the Perl Artistic
 License Version 2.0.

bin/verilator_ccache_report

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+# mypy: disallow-untyped-defs
 # pylint: disable=C0103,C0114,C0115,C0116,C0123,C0209,C0301,R0902,R0913,R0914,R0912,R0915,W0621
 ######################################################################
 
@@ -16,8 +17,7 @@ parser = argparse.ArgumentParser(
 
     For documentation see
     https://verilator.org/guide/latest/exe_verilator_ccache_report.html""",
-    epilog=
-    """Copyright 2002-2023 by Wilson Snyder. This program is free software; you
+    epilog="""Copyright 2002-2025 by Wilson Snyder. This program is free software; you
 can redistribute it and/or modify it under the terms of either the GNU
 Lesser General Public License Version 3 or the Perl Artistic License
 Version 2.0.
@@ -37,7 +37,7 @@ results = {}
 elapsed = {}
 
 
-def toDateTime(s):
+def toDateTime(s: str) -> datetime:
     return datetime.strptime(s, "%Y-%m-%dT%H:%M:%S.%f")
 
 
@@ -54,6 +54,7 @@ for logfile in args.logdir.iterdir():
             match = re.match(r'\[(\S+)\s.*Result: (.*)$', line)
             if match:
                 assert obj is not None
+                assert start is not None
                 elapsed[obj] = toDateTime(match.group(1)) - start
                 results[obj] = match.group(2)
 
@@ -67,30 +68,23 @@ else:
     wnames = max(len(_) for _ in results) + 1
     wresults = max(len(_) for _ in results.values()) + 1
     for k in sorted(results.keys()):
-        args.o.write("{:{wnames}} : {:{wresults}} : {}s\n".format(
-            k,
-            results[k],
-            elapsed[k].total_seconds(),
-            wnames=wnames,
-            wresults=wresults))
+        args.o.write("{:{wnames}} : {:{wresults}} : {}s\n".format(k,
+                                                                  results[k],
+                                                                  elapsed[k].total_seconds(),
+                                                                  wnames=wnames,
+                                                                  wresults=wresults))
 
     args.o.write("\nSummary:\n")
     counts = collections.Counter(_ for _ in results.values())
     total = sum(counts.values())
     for k in sorted(counts.keys()):
         c = counts[k]
-        args.o.write("{:{width}}| {} ({:.2%})\n".format(k,
-                                                        c,
-                                                        c / total,
-                                                        width=wresults))
+        args.o.write("{:{width}}| {} ({:.2%})\n".format(k, c, c / total, width=wresults))
 
     args.o.write("\nLongest:\n")
-    longest = sorted(list(elapsed.items()),
-                     key=lambda kv: -kv[1].total_seconds())
+    longest = sorted(list(elapsed.items()), key=lambda kv: -kv[1].total_seconds())
     for i, (k, v) in enumerate(longest):
-        args.o.write("{:{width}}| {}s\n".format(k,
-                                                v.total_seconds(),
-                                                width=wnames))
+        args.o.write("{:{width}}| {}s\n".format(k, v.total_seconds(), width=wnames))
         if i > 4:
             break
 

bin/verilator_coverage

@@ -1,7 +1,7 @@
 #!/usr/bin/env perl
 ######################################################################
 #
-# Copyright 2003-2023 by Wilson Snyder. This program is free software; you
+# Copyright 2003-2025 by Wilson Snyder. This program is free software; you
 # can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
@@ -118,21 +118,24 @@ sub run {
             warn "%Error: export VERILATOR_ROOT=" . ($ENV{VERILATOR_ROOT} || "") . "\n";
             warn "%Error: $command\n";
         }
-        if ($status & 127) {
-            if (($status & 127) == 8 || ($status & 127) == 11) {  # SIGFPA or SIGSEGV
+        my $signal = ($status & 127);
+        if ($signal) {
+            if ($signal == 4  # SIGILL
+                || $signal == 8  # SIGFPA
+                || $signal == 11) {  # SIGSEGV
                 warn "%Error: Verilator_coverage internal fault, sorry.\n" if !$Debug;
-            } elsif (($status & 127) == 6) {  # SIGABRT
+            } elsif ($signal == 6) {  # SIGABRT
                 warn "%Error: Verilator_coverage aborted.\n" if !$Debug;
             } else {
-                warn "%Error: Verilator_coverage threw signal $status.\n" if !$Debug;
+                warn "%Error: Verilator_coverage threw signal $signal.\n" if !$Debug;
             }
         }
         if ($status != 256 || $Debug) {  # i.e. not normal exit(1)
             warn "%Error: Command Failed $command\n";
         }
         exit $! if $!;  # errno
-        exit $? >> 8 if $? >> 8;  # child exit status
-        exit 255;  # last resort
+        exit $? >> 8 if $? >> 8;  # pass along child exit code
+        exit 128 + $signal;  # last resort
     }
 }
 
@@ -154,9 +157,9 @@ verilator_coverage - Verilator coverage analyzer
 
     verilator_coverage --annotate <obj>
 
-    verilator_coverage  -write merged.dat -read <datafiles>...
+    verilator_coverage  -write merged.dat <datafiles>...
 
-    verilator_coverage  -write-info merged.info -read <datafiles>...
+    verilator_coverage  -write-info merged.info <datafiles>...
 
 Verilator_coverage processes Verilated model-generated coverage reports.
 
@@ -170,6 +173,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
@@ -177,18 +181,18 @@ L<https://verilator.org/guide/latest/exe_verilator_coverage.html>.
     --write <filename>            Write aggregate coverage results.
     --write-info <filename.info>  Write lcov .info.
 
-    +libext+I<ext>+I<ext>...      Extensions for Verilog files.
-    +define+I<var>+I<value>       Defines the given variable.
-    -DI<var>=I<value>             Defines the given variable.
-    +incdir+I<dir>                Add directory for finding include files.
-    -II<dir>                      Add directory for finding include files.
-    -y I<dir>                     Specifies module search directory.
+    +libext+<ext>+<ext>...        Extensions for Verilog files.
+    +define+<var>+<value>         Defines the given variable.
+    -D<var>=<value>               Defines the given variable.
+    +incdir+<dir>                 Add directory for finding include files.
+    -I<dir>                       Add directory for finding include files.
+    -y <dir>                      Specifies module search directory.
 
 =head1 DISTRIBUTION
 
 The latest version is available from L<https://verilator.org>.
 
-Copyright 2003-2023 by Wilson Snyder. This program is free software; you
+Copyright 2003-2025 by Wilson Snyder. This program is free software; you
 can redistribute it and/or modify the Verilator internals under the terms
 of either the GNU Lesser General Public License Version 3 or the Perl
 Artistic License Version 2.0.

bin/verilator_difftree

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
-# pylint: disable=C0103,C0114,C0116,C0209
+# mypy: disallow-untyped-defs
+# pylint: disable=C0103,C0114,C0116,C0209,W0603
 ######################################################################
 
 import argparse
@@ -9,25 +10,29 @@ import os.path
 import re
 import sys
 
+exit_code = 0
 
-def diff(a, b):
 
+def diff(a: str, b: str) -> None:
     if not os.path.exists(a):
-        sys.exit("%Error: No old diff filename found: " + a)
+        sys.stderr.write("%Error: No old diff filename found: " + a + "\n")
+        sys.exit(2)
     if not os.path.exists(b):
-        sys.exit("%Error: No new diff filename found: " + b)
+        sys.stderr.write("%Error: No new diff filename found: " + b + "\n")
+        sys.exit(2)
 
     if os.path.isdir(a) and os.path.isdir(b):
         diff_dir(a, b)
     elif os.path.isfile(a) and os.path.isfile(b):
         diff_file(a, b)
     else:
-        sys.exit("%Error: Mix of files and dirs")
+        sys.stderr.write("%Error: Mix of files and dirs")
+        sys.exit(2)
 
 
-def diff_dir(a, b):
+def diff_dir(a: str, b: str) -> None:
     # Diff all files under two directories
-    files = collections.defaultdict(lambda: {})
+    files: dict[str, dict[str, str]] = collections.defaultdict(lambda: {})
 
     for fn in glob.glob(a + "/*.tree"):
         base = re.sub(r'.*/', '', fn)
@@ -47,11 +52,12 @@ def diff_dir(a, b):
         diff_file(a, b)
         anyfile = True
     if not anyfile:
-        sys.stderr.write(
-            "%Warning: No .tree files found that have similar base names\n")
+        sys.stderr.write("%Warning: No .tree files found that have similar base names\n")
 
 
-def diff_file(a, b):
+def diff_file(a: str, b: str) -> None:
+    global exit_code
+
     # Compare the two tree files
     short_a = re.sub(r'[^a-zA-Z0-9.]+', '_', a)
     short_b = re.sub(r'[^a-zA-Z0-9.]+', '_', b)
@@ -66,25 +72,18 @@ def diff_file(a, b):
 
     filterf(a, tmp_a)
     filterf(b, tmp_b)
-    os.system("diff -u " + tmp_a + " " + tmp_b)
+    status = os.system("diff -u " + tmp_a + " " + tmp_b)
     os.unlink(tmp_a)
     os.unlink(tmp_b)
 
-
-def version_from(filename):
-    # Return dump format
-    with open(filename, "r", encoding="utf8") as fh:
-        lineno = 0
-        for line in fh:
-            if lineno > 10:
-                break
-            match = re.search(r'format (0x[0-9.]+)', line)
-            if match:
-                return hex(match.group(1))
-    return 1.0
+    status_exit_code = status >> 8
+    if status_exit_code == 1:
+        exit_code = 1
+    elif status_exit_code:
+        exit_code = 2
 
 
-def filterf(fn1, fn2):
+def filterf(fn1: str, fn2: str) -> None:
     # Remove hex numbers before diffing
     with open(fn1, "r", encoding="utf8") as fh1:
         with open(fn2, "w", encoding="utf8") as fh2:
@@ -108,19 +107,17 @@ parser = argparse.ArgumentParser(
 
 Verilator_difftree is used for debugging Verilator tree output files.
 It performs a diff between two files, or all files common between two
-directories, ignoring irrelevant pointer differences.""",
-    epilog=
-    """Copyright 2005-2023 by Wilson Snyder. This program is free software; you
+directories, ignoring irrelevant pointer differences.
+
+Exit status is 0 if inputs are the same, 1 if different, 2 if trouble.""",
+    epilog="""Copyright 2005-2025 by Wilson Snyder. This program is free software; you
 can redistribute it and/or modify it under the terms of either the GNU
 Lesser General Public License Version 3 or the Perl Artistic License
 Version 2.0.
 
 SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0""")
 
-parser.add_argument('--debug',
-                    action='store_const',
-                    const=9,
-                    help='enable debug')
+parser.add_argument('--debug', action='store_const', const=9, help='enable debug')
 parser.add_argument('--no-lineno',
                     action='store_false',
                     help='do not show differences in line numbering')
@@ -129,6 +126,7 @@ parser.add_argument('fileb', help='input file b to diff')
 
 Args = parser.parse_args()
 diff(Args.filea, Args.fileb)
+sys.exit(exit_code)
 
 ######################################################################
 # Local Variables:

bin/verilator_gantt

@@ -1,52 +1,66 @@
 #!/usr/bin/env python3
-# pylint: disable=C0103,C0114,C0116,C0209,C0301,R0914,R0912,R0915,W0511,eval-used
+# pylint: disable=C0103,C0114,C0116,C0209,C0301,R0914,R0912,R0915,W0511,W0603,eval-used
 ######################################################################
 
 import argparse
+import bisect
 import collections
 import math
 import re
 import statistics
+from collections import OrderedDict
 # from pprint import pprint
 
-Threads = collections.defaultdict(lambda: collections.defaultdict(lambda: {}))
-Mtasks = collections.defaultdict(lambda: {})
-Evals = collections.defaultdict(lambda: {})
-EvalLoops = collections.defaultdict(lambda: {})
+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: {}),
-    'rdtsc_cycle_time': 0,
+    'info': {
+        'numa': 'no data'
+    },
     'stats': {}
 }
+ElapsedTime = None  # total elapsed time
+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
 
 ######################################################################
 
 
-def process(filename):
-    read_data(filename)
-    report()
-
-
-def read_data(filename):
+def read_data(filename: str) -> None:
     with open(filename, "r", encoding="utf8") as fh:
         re_thread = re.compile(r'^VLPROFTHREAD (\d+)$')
         re_record = re.compile(r'^VLPROFEXEC (\S+) (\d+)(.*)$')
+        # The hierBlock argument is optional
         re_payload_mtaskBegin = re.compile(
-            r'id (\d+) predictStart (\d+) cpu (\d+)')
-        re_payload_mtaskEnd = re.compile(r'id (\d+) predictCost (\d+)')
+            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_time = re.compile(r'rdtsc time = (\d+) ticks')
+        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 = None
+        thread = 0
+        thread_last_ecpu = None
 
-        lastEvalBeginTick = None
-        lastEvalLoopBeginTick = None
+        global LongestVcdStrValueLength
+        global ExecGraphTime
+        global WaitingTime
+
+        ExecGraphStack = []
+        SectionStack = []
+        MtasksStack = []
+        ThreadScheduleWait = collections.defaultdict(list)
 
         for line in fh:
             recordMatch = re_record.match(line)
@@ -54,47 +68,70 @@ def read_data(filename):
                 kind, tick, payload = recordMatch.groups()
                 tick = int(tick)
                 payload = payload.strip()
-                if kind == "EVAL_BEGIN":
-                    Evals[tick]['start'] = tick
-                    lastEvalBeginTick = tick
-                elif kind == "EVAL_END":
-                    Evals[lastEvalBeginTick]['end'] = tick
-                    lastEvalBeginTick = None
-                elif kind == "EVAL_LOOP_BEGIN":
-                    EvalLoops[tick]['start'] = tick
-                    lastEvalLoopBeginTick = tick
-                elif kind == "EVAL_LOOP_END":
-                    EvalLoops[lastEvalLoopBeginTick]['end'] = tick
-                    lastEvalLoopBeginTick = None
+                if kind == "SECTION_PUSH":
+                    LongestVcdStrValueLength = max(LongestVcdStrValueLength, len(payload))
+                    SectionStack.append(payload)
+                    Sections[thread].append((tick, tuple(SectionStack)))
+                elif kind == "SECTION_POP":
+                    assert SectionStack, "SECTION_POP without SECTION_PUSH"
+                    SectionStack.pop()
+                    Sections[thread].append((tick, tuple(SectionStack)))
                 elif kind == "MTASK_BEGIN":
-                    mtask, predict_start, ecpu = re_payload_mtaskBegin.match(
+                    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)
-                    Threads[thread][tick]['mtask'] = mtask
-                    Threads[thread][tick]['predict_start'] = predict_start
-                    Threads[thread][tick]['cpu'] = ecpu
-                    if 'elapsed' not in Mtasks[mtask]:
-                        Mtasks[mtask] = {'end': 0, 'elapsed': 0}
-                    Mtasks[mtask]['begin'] = tick
-                    Mtasks[mtask]['thread'] = thread
-                    Mtasks[mtask]['predict_start'] = predict_start
+                    records = Threads[thread]
+                    records.append({
+                        'start': tick,
+                        'mtask': mtask,
+                        'predict_start': predict_start,
+                        'hier_block': hier_block,
+                        'cpu': ecpu
+                    })
+                    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']
-                    Threads[thread][begin]['end'] = tick
-                    Threads[thread][begin]['predict_cost'] = predict_cost
-                    Mtasks[mtask]['elapsed'] += tick - begin
-                    Mtasks[mtask]['predict_cost'] = predict_cost
-                    Mtasks[mtask]['end'] = max(Mtasks[mtask]['end'], tick)
+                    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[(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])
+                    thread_last_ecpu = ecpu
+                    ThreadScheduleWait[ecpu].append(tick)
+                elif kind == "THREAD_SCHEDULE_WAIT_END":
+                    # Might have ended on different CPU then we got THREAD_SCHEDULE_WAIT_BEGIN
+                    assert thread_last_ecpu is not None, "THREAD_SCHEDULE_WAIT_END without BEGIN"
+                    ecpu = thread_last_ecpu
+                    thread_last_ecpu = None
+                    start = ThreadScheduleWait[ecpu].pop()
+                    WaitingTime += tick - start
+                    ThreadScheduleWaitIntervals.append((start, tick, ecpu))
+                elif kind == "EXEC_GRAPH_BEGIN":
+                    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))
                 elif Args.debug:
                     print("-Unknown execution trace record: %s" % line)
             elif re_thread.match(line):
                 thread = int(re_thread.match(line).group(1))
+                Sections[thread] = []
             elif re.match(r'^VLPROF(THREAD|VERSION)', line):
                 pass
             elif re_arg1.match(line):
@@ -103,13 +140,16 @@ 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)
             elif re_proc_cpu.match(line):
                 match = re_proc_cpu.match(line)
                 cpu = int(match.group(1))
-            elif cpu and re_proc_dat.match(line):
+            elif cpu is not None and re_proc_dat.match(line):
                 match = re_proc_dat.match(line)
                 term = match.group(1)
                 value = match.group(2)
@@ -121,11 +161,6 @@ def read_data(filename):
                 pass
             elif Args.debug:
                 print("-Unk: %s" % line)
-            # TODO -- this is parsing text printed by a client.
-            # Really, verilator proper should generate this
-            # if it's useful...
-            if re_time.match(line):
-                Global['rdtsc_cycle_time'] = re_time.group(1)
 
 
 def re_match_result(regexp, line, result_to):
@@ -136,7 +171,7 @@ def re_match_result(regexp, line, result_to):
 ######################################################################
 
 
-def report():
+def report() -> None:
     print("Verilator Gantt report")
 
     print("\nArgument settings:")
@@ -144,34 +179,57 @@ def report():
         plus = "+" if re.match(r'^\+', arg) else " "
         print("  %s%s%s" % (arg, plus, Global['args'][arg]))
 
-    nthreads = int(Global['stats']['threads'])
-    Global['cpus'] = {}
-    for thread in Threads:
-        # Make potentially multiple characters per column
-        for start in Threads[thread]:
-            if not Threads[thread][start]:
-                continue
-            cpu = Threads[thread][start]['cpu']
-            elapsed = Threads[thread][start]['end'] - start
-            if cpu not in Global['cpus']:
-                Global['cpus'][cpu] = {'cpu_time': 0}
-            Global['cpus'][cpu]['cpu_time'] += elapsed
+    for records in Threads.values():
+        for record in records:
+            cpu = record['cpu']
+            elapsed = record['end'] - record['start']
+            Cpus[cpu]['mtask_time'] += elapsed
 
-    measured_mt_mtask_time = 0
-    predict_mt_mtask_time = 0
-    long_mtask_time = 0
-    measured_last_end = 0
-    predict_last_end = 0
-    for mtask in Mtasks:
-        measured_mt_mtask_time += Mtasks[mtask]['elapsed']
-        predict_mt_mtask_time += Mtasks[mtask]['predict_cost']
-        measured_last_end = max(measured_last_end, Mtasks[mtask]['end'])
-        predict_last_end = max(
-            predict_last_end,
-            Mtasks[mtask]['predict_start'] + Mtasks[mtask]['predict_cost'])
-        long_mtask_time = max(long_mtask_time, Mtasks[mtask]['elapsed'])
-    Global['measured_last_end'] = measured_last_end
-    Global['predict_last_end'] = predict_last_end
+    global ElapsedTime
+    ElapsedTime = int(Global['stats']['ticks'])
+    nthreads = int(Global['stats']['threads'])
+    ncpus = max(len(Cpus), 1)
+
+    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()
+
+    if nthreads > ncpus:
+        print()
+        print("%%Warning: There were fewer CPUs (%d) than threads (%d)." % (ncpus, nthreads))
+        print("        : See docs on use of numactl.")
+    else:
+        if 'cpu_socket_cores_warning' in Global:
+            print()
+            print("%Warning: Multiple threads scheduled on same hyperthreaded core.")
+            print("        : See docs on use of numactl.")
+        if 'cpu_sockets_warning' in Global:
+            print()
+            print("%Warning: Threads scheduled on multiple sockets.")
+            print("        : See docs on use of numactl.")
+    print()
+
+
+def report_numa() -> None:
+    print("\nNUMA assignment:")
+    print("  NUMA status        = %s" % Global['info']['numa'])
+
+
+def report_mtasks() -> None:
+    if not Mtasks:
+        return
+
+    nthreads = int(Global['stats']['threads'])
 
     # If we know cycle time in the same (rdtsc) units,
     # this will give us an actual utilization number,
@@ -181,130 +239,136 @@ def report():
     # serial mode, to estimate the overhead of data sharing,
     # which will show up in the total elapsed time. (Overhead
     # of synchronization and scheduling should not.)
-    print("\nAnalysis:")
-    print("  Total threads             = %d" % nthreads)
-    print("  Total mtasks              = %d" % len(Mtasks))
-    ncpus = max(len(Global['cpus']), 1)
-    print("  Total cpus used           = %d" % ncpus)
-    print("  Total yields              = %d" %
-          int(Global['stats'].get('yields', 0)))
-    print("  Total evals               = %d" % len(Evals))
-    print("  Total eval loops          = %d" % len(EvalLoops))
-    if Mtasks:
-        print("  Total eval time           = %d rdtsc ticks" %
-              Global['measured_last_end'])
-        print("  Longest mtask time        = %d rdtsc ticks" % long_mtask_time)
-        print("  All-thread mtask time     = %d rdtsc ticks" %
-              measured_mt_mtask_time)
-        long_efficiency = long_mtask_time / (Global.get(
-            'measured_last_end', 1) or 1)
-        print("  Longest-thread efficiency = %0.1f%%" %
-              (long_efficiency * 100.0))
-        mt_efficiency = measured_mt_mtask_time / (
-            Global.get('measured_last_end', 1) * nthreads or 1)
-        print("  All-thread efficiency     = %0.1f%%" %
-              (mt_efficiency * 100.0))
-        print("  All-thread speedup        = %0.1f" %
-              (mt_efficiency * nthreads))
-        if Global['rdtsc_cycle_time'] > 0:
-            ut = measured_mt_mtask_time / Global['rdtsc_cycle_time']
-            print("tot_mtask_cpu=" + measured_mt_mtask_time + " cyc=" +
-                  Global['rdtsc_cycle_time'] + " ut=" + ut)
+    total_mtask_time = 0
+    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 (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']
+        predict_end = record['predict_start'] + record['predict_cost']
+        predict_elapsed = max(predict_elapsed, predict_end)
+        if record['elapsed'] > long_mtask_time:
+            long_mtask_time = record['elapsed']
+            long_mtask = mtask_id
+            long_mtask_hier_block = hier_block
+    Global['predict_last_end'] = predict_elapsed
 
-        predict_mt_efficiency = predict_mt_mtask_time / (
-            Global.get('predict_last_end', 1) * nthreads or 1)
-        print("\nPrediction (what Verilator used for scheduling):")
-        print("  All-thread efficiency     = %0.1f%%" %
-              (predict_mt_efficiency * 100.0))
-        print("  All-thread speedup        = %0.1f" %
-              (predict_mt_efficiency * nthreads))
+    serialTime = ElapsedTime - ExecGraphTime
 
-        p2e_ratios = []
-        min_p2e = 1000000
-        min_mtask = None
-        max_p2e = -1000000
-        max_mtask = None
+    def subReport(elapsed, work):
+        print("  Thread utilization = {:7.2%}".format(work / (elapsed * nthreads)))
+        print("  Speedup            = {:6.3}x".format(work / elapsed))
 
-        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'])
-                p2e_ratios.append(p2e_ratio)
+    print("\nParallelized code, measured:")
+    subReport(ExecGraphTime, total_mtask_time)
 
-                if p2e_ratio > max_p2e:
-                    max_p2e = p2e_ratio
-                    max_mtask = mtask
-                if p2e_ratio < min_p2e:
-                    min_p2e = p2e_ratio
-                    min_mtask = mtask
+    print("\nParallelized code, predicted during static scheduling:")
+    subReport(predict_elapsed, predict_mtask_time)
 
-        print("\nMTask statistics:")
-        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'])
-        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'])
+    print("\nAll code, measured:")
+    subReport(ElapsedTime, serialTime + total_mtask_time)
 
-        stddev = statistics.pstdev(p2e_ratios)
-        mean = statistics.mean(p2e_ratios)
-        print("  mean = %0.3f" % mean)
-        print("  stddev = %0.3f" % stddev)
-        print("  e ^ stddev = %0.3f" % math.exp(stddev))
+    print("\nAll code, measured, scaled by predicted speedup:")
+    expectedParallelSpeedup = predict_mtask_time / predict_elapsed
+    scaledElapsed = serialTime + total_mtask_time / expectedParallelSpeedup
+    subReport(scaledElapsed, serialTime + total_mtask_time)
 
-    report_cpus()
+    p2e_ratios = []
+    min_p2e = 1000000
+    min_mtask = None
+    max_p2e = -1000000
+    max_mtask = None
 
-    if nthreads > ncpus:
-        print()
-        print("%%Warning: There were fewer CPUs (%d) then threads (%d)." %
-              (ncpus, nthreads))
-        print("        : See docs on use of numactl.")
+    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_id
+                max_hier_block = hier_block
+            if p2e_ratio < min_p2e:
+                min_p2e = p2e_ratio
+                min_mtask = mtask_id
+                min_hier_block = hier_block
+
+    print("\nMTask statistics:")
+    if long_mtask_hier_block:
+        print("  Longest mtask id = {} from hier_block '{}'".format(long_mtask,
+                                                                    long_mtask_hier_block))
     else:
-        if 'cpu_socket_cores_warning' in Global:
-            print()
-            print(
-                "%Warning: Multiple threads scheduled on same hyperthreaded core."
-            )
-            print("        : See docs on use of numactl.")
-        if 'cpu_sockets_warning' in Global:
-            print()
-            print("%Warning: Threads scheduled on multiple sockets.")
-            print("        : See docs on use of numactl.")
-    print()
+        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="")
+
+    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="")
+    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)
+    print("  mean = %0.3f" % mean)
+    print("  stddev = %0.3f" % stddev)
+    print("  e ^ stddev = %0.3f" % math.exp(stddev))
 
 
-def report_cpus():
-    print("\nCPUs:")
+def report_cpus() -> None:
+    print("\nCPU info:")
 
     Global['cpu_sockets'] = collections.defaultdict(lambda: 0)
     Global['cpu_socket_cores'] = collections.defaultdict(lambda: 0)
 
-    for cpu in sorted(Global['cpus'].keys()):
-        print("  cpu %d: " % cpu, end='')
-        print("cpu_time=%d" % Global['cpus'][cpu]['cpu_time'], end='')
-
-        socket = None
+    print("   Id | Time spent executing MTask | Socket | Core | Model")
+    print("      | % of elapsed ticks / ticks |        |      |")
+    print("  ====|============================|========|======|======")
+    for cpu in sorted(Cpus):
+        socket = ""
+        core = ""
+        model = ""
         if cpu in Global['cpuinfo']:
             cpuinfo = Global['cpuinfo'][cpu]
             if 'physical_id' in cpuinfo and 'core_id' in cpuinfo:
-                socket = int(cpuinfo['physical_id'])
+                socket = cpuinfo['physical_id']
                 Global['cpu_sockets'][socket] += 1
-                print(" socket=%d" % socket, end='')
-
-                core = int(cpuinfo['core_id'])
-                Global['cpu_socket_cores'][str(socket) + "__" + str(core)] += 1
-                print(" core=%d" % core, end='')
+                core = cpuinfo['core_id']
+                Global['cpu_socket_cores'][socket + "__" + core] += 1
 
             if 'model_name' in cpuinfo:
                 model = cpuinfo['model_name']
-                print("  %s" % model, end='')
-        print()
+
+        print("  {:3d} | {:7.2%} / {:16d} | {:>6s} | {:>4s} | {}".format(
+            cpu, Cpus[cpu]['mtask_time'] / ElapsedTime, Cpus[cpu]['mtask_time'], socket, core,
+            model))
 
     if len(Global['cpu_sockets']) > 1:
         Global['cpu_sockets_warning'] = True
@@ -313,25 +377,72 @@ def report_cpus():
                 Global['cpu_socket_cores_warning'] = True
 
 
+def report_sections() -> None:
+    for thread, section in Sections.items():
+        if section:
+            print(f"\nSection profile for thread {thread}:")
+            report_section(section)
+
+
+def report_section(section) -> None:
+    totalTime = collections.defaultdict(lambda: 0)
+    selfTime = collections.defaultdict(lambda: 0)
+
+    sectionTree = [0, {}, 1]  # [selfTime, childTrees, numberOfTimesEntered]
+    prevTime = 0
+    prevStack = ()
+    for time, stack in section:
+        if len(stack) > len(prevStack):
+            scope = sectionTree
+            for item in stack:
+                scope = scope[1].setdefault(item, [0, {}, 0])
+            scope[2] += 1
+        dt = time - prevTime
+        assert dt >= 0
+        scope = sectionTree
+        for item in prevStack:
+            scope = scope[1].setdefault(item, [0, {}, 0])
+        scope[0] += dt
+
+        if prevStack:
+            for name in prevStack:
+                totalTime[name] += dt
+            selfTime[prevStack[-1]] += dt
+        prevTime = time
+        prevStack = stack
+
+    def treeSum(tree):
+        n = tree[0]
+        for subTree in tree[1].values():
+            n += treeSum(subTree)
+        return n
+
+    # Make sure the tree sums to the elapsed time
+    sectionTree[0] += ElapsedTime - treeSum(sectionTree)
+
+    def printTree(prefix, name, entries, tree):
+        print("  {:7.2%} | {:7.2%} | {:8} | {:10.2f} | {}".format(
+            treeSum(tree) / ElapsedTime, tree[0] / ElapsedTime, tree[2], tree[2] / entries,
+            prefix + name))
+        for k in sorted(tree[1], key=lambda _: -treeSum(tree[1][_])):
+            printTree(prefix + "  ", k, tree[2], tree[1][k])
+
+    print(" Total    | Self    | Total    | Relative   | Section")
+    print(" time     | time    | entries  | entries    |  name  ")
+    print("==========|=========|==========|============|========")
+    printTree("", "*TOTAL*", 1, sectionTree)
+
+
 ######################################################################
 
 
-def write_vcd(filename):
+def write_vcd(filename: str) -> None:
     print("Writing %s" % filename)
     with open(filename, "w", encoding="utf8") as fh:
-        vcd = {
-            'values':
-            collections.defaultdict(lambda: {}),  # {<time>}{<code>} = value
-            'sigs': {
-                'predicted_threads': {},
-                'measured_threads': {},
-                'cpus': {},
-                'evals': {},
-                'mtasks': {},
-                'Stats': {}
-            }  # {<module>}{<sig}} = code
-        }
-        code = 0
+        # dict of dicts of hierarchy elements/signal name  -> (code, width)
+        scopeSigs = {}
+        # map from time -> code -> value
+        values = collections.defaultdict(lambda: {})
 
         parallelism = {
             'measured': collections.defaultdict(lambda: 0),
@@ -340,132 +451,151 @@ def write_vcd(filename):
         parallelism['measured'][0] = 0
         parallelism['predicted'][0] = 0
 
-        # Measured graph
-        for thread in sorted(Threads.keys()):
-            sig = "thread%d_mtask" % thread
-            if sig not in vcd['sigs']['measured_threads']:
-                vcd['sigs']['measured_threads'][sig] = code
-                code += 1
-            mcode = vcd['sigs']['measured_threads'][sig]
+        nextFreeCode = 0
 
-            for start in sorted(Threads[thread]):
-                mtask = Threads[thread][start]['mtask']
-                end = Threads[thread][start]['end']
-                cpu = Threads[thread][start]['cpu']
-                vcd['values'][start][mcode] = mtask
-                vcd['values'][end][mcode] = None
+        def getCode(width, *names):
+            nonlocal nextFreeCode
+            scope = scopeSigs
+            *path, name = names
+            for item in path:
+                scope = scope.setdefault(item, {})
+            code, oldWidth = scope.setdefault(name, (nextFreeCode, width))
+            assert oldWidth == width
+            if code == nextFreeCode:
+                nextFreeCode += 1
+            return code
+
+        def addValue(code, time, val):
+            if isinstance(val, str):
+                buf = ""
+                for c in val:
+                    buf += bin(ord(c))[2:].rjust(8, "0")
+                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)
+            for record in Threads[thread]:
+                start = record['start']
+                mtask = record['mtask']
+                end = record['end']
+                cpu = record['cpu']
+                addValue(mcode, start, mtask)
+                addValue(mcode, end, None)
                 parallelism['measured'][start] += 1
                 parallelism['measured'][end] -= 1
 
-                sig = "cpu%d_thread" % cpu
-                if sig not in vcd['sigs']['cpus']:
-                    vcd['sigs']['cpus'][sig] = code
-                    code += 1
-                ccode = vcd['sigs']['cpus'][sig]
-                vcd['values'][start][ccode] = thread
-                vcd['values'][end][ccode] = None
+                code = getCode(32, 'measured', 'cpu%d_thread' % cpu)
+                addValue(code, start, thread)
+                addValue(code, end, None)
 
-                sig = "mtask%d_cpu" % mtask
-                if sig not in vcd['sigs']['mtasks']:
-                    vcd['sigs']['mtasks'][sig] = code
-                    code += 1
-                ccode = vcd['sigs']['mtasks'][sig]
-                vcd['values'][start][ccode] = cpu
-                vcd['values'][end][ccode] = None
+                code = getCode(32, 'measured', 'cpu%d_mtask' % cpu)
+                addValue(code, start, mtask)
+                addValue(code, end, None)
 
-        # Eval graph
-        vcd['sigs']['evals']["eval"] = code
-        elcode = code
-        code += 1
-        n = 0
-        for eval_start in Evals:
-            eval_end = Evals[eval_start]['end']
-            n += 1
-            vcd['values'][eval_start][elcode] = n
-            vcd['values'][eval_end][elcode] = None
+        tStart = sorted(_['start'] for records in Threads.values() for _ in records)
+        tEnd = sorted(_['end'] for records in Threads.values() for _ in records)
 
-        # Eval_loop graph
-        vcd['sigs']['evals']["eval_loop"] = code
-        elcode = code
-        code += 1
-        n = 0
-        for eval_start in EvalLoops:
-            eval_end = EvalLoops[eval_start]['end']
-            n += 1
-            vcd['values'][eval_start][elcode] = n
-            vcd['values'][eval_end][elcode] = None
+        # Measured waiting time
+        for (start, end, cpu) in ThreadScheduleWaitIntervals:
+            mcode = getCode(32, 'measured', 'cpu%d_waiting' % cpu)
+            addXValue(mcode, start)
+            addValue(mcode, end, None)
 
-        if Mtasks:
-            # Predicted graph
-            for eval_start in EvalLoops:
-                eval_end = EvalLoops[eval_start]['end']
-                # Compute scale so predicted graph is of same width as eval
-                measured_scaling = (eval_end -
-                                    eval_start) / Global['predict_last_end']
-                # Predict mtasks that fill the time the eval occupied
-                for mtask in Mtasks:
-                    thread = Mtasks[mtask]['thread']
-                    pred_scaled_start = eval_start + int(
-                        Mtasks[mtask]['predict_start'] * measured_scaling)
-                    pred_scaled_end = eval_start + int(
-                        (Mtasks[mtask]['predict_start'] +
-                         Mtasks[mtask]['predict_cost']) * measured_scaling)
-                    if pred_scaled_start == pred_scaled_end:
-                        continue
+        # 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
+            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 (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(
+                    (mtask['predict_start'] + mtask['predict_cost']) * measured_scaling)
+                if pred_scaled_start == pred_scaled_end:
+                    continue
 
-                    sig = "predicted_thread%d_mtask" % thread
-                    if sig not in vcd['sigs']['predicted_threads']:
-                        vcd['sigs']['predicted_threads'][sig] = code
-                        code += 1
-                    mcode = vcd['sigs']['predicted_threads'][sig]
+                mcode = getCode(32, 'predicted', 't%d_mtask' % thread)
+                addValue(mcode, pred_scaled_start, mtask_id)
+                addValue(mcode, pred_scaled_end, None)
 
-                    vcd['values'][pred_scaled_start][mcode] = mtask
-                    vcd['values'][pred_scaled_end][mcode] = None
+                parallelism['predicted'][pred_scaled_start] += 1
+                parallelism['predicted'][pred_scaled_end] -= 1
 
-                    parallelism['predicted'][pred_scaled_start] += 1
-                    parallelism['predicted'][pred_scaled_end] -= 1
+        # Parallelism graph
+        for measpred in ('measured', 'predicted'):
+            pcode = getCode(32, 'stats', '%s_parallelism' % measpred)
+            value = 0
+            for time in sorted(parallelism[measpred].keys()):
+                value += parallelism[measpred][time]
+                addValue(pcode, time, value)
 
-            # Parallelism graph
-            for measpred in ('measured', 'predicted'):
-                vcd['sigs']['Stats']["%s_parallelism" % measpred] = code
-                pcode = code
-                code += 1
-                value = 0
-                for time in sorted(parallelism[measpred].keys()):
-                    value += parallelism[measpred][time]
-                    vcd['values'][time][pcode] = value
+        # Section graph
+        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")
+                for time, stack in section:
+                    addValue(scode, time, stack[-1] if stack else None)
+                    addValue(dcode, time, len(stack))
 
         # Create output file
         fh.write("$version Generated by verilator_gantt $end\n")
         fh.write("$timescale 1ns $end\n")
         fh.write("\n")
 
-        all_codes = {}
+        all_codes = set()
+
+        def writeScope(scope):
+            assert isinstance(scope, dict)
+            for key in sorted(scope):
+                val = scope[key]
+                if isinstance(val, dict):
+                    fh.write("  $scope module %s $end\n" % key)
+                    writeScope(val)
+                    fh.write("  $upscope $end\n")
+                else:
+                    (code, width) = val
+                    all_codes.add(code)
+                    fh.write("   $var wire %d v%x %s [%d:0] $end\n" %
+                             (width, code, key, width - 1))
+
         fh.write(" $scope module gantt $end\n")
-        for module in sorted(vcd['sigs'].keys()):
-            fh.write("  $scope module %s $end\n" % module)
-            for sig in sorted(vcd['sigs'][module].keys()):
-                code = vcd['sigs'][module][sig]
-                fh.write("   $var wire 32 v%x %s [31:0] $end\n" % (code, sig))
-                all_codes[code] = 1
-            fh.write("  $upscope $end\n")
+        writeScope(scopeSigs)
         fh.write(" $upscope $end\n")
         fh.write("$enddefinitions $end\n")
         fh.write("\n")
 
         first = True
-        for time in sorted(vcd['values']):
+        for time in sorted(values):
             if first:
                 first = False
                 # Start with Z for any signals without time zero data
-                for code in sorted(all_codes.keys()):
-                    if code not in vcd['values'][time]:
-                        vcd['values'][time][code] = None
+                for code in sorted(all_codes):
+                    if code not in values[time]:
+                        addValue(code, time, None)
             fh.write("#%d\n" % time)
-            for code in sorted(vcd['values'][time].keys()):
-                value = vcd['values'][time][code]
+            for code in sorted(values[time]):
+                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:
                     fh.write("b%s v%x\n" % (format(value, 'b'), code))
 
@@ -475,7 +605,7 @@ def write_vcd(filename):
 parser = argparse.ArgumentParser(
     allow_abbrev=False,
     formatter_class=argparse.RawDescriptionHelpFormatter,
-    description="""Create Gantt chart of multi-threaded execution.
+    description="""Create Gantt chart of Verilator multi-threaded execution
 
 Verilator_gantt creates a visual representation to help analyze Verilator
 #xmultithreaded simulation performance, by showing when each macro-task
@@ -483,8 +613,7 @@ Verilator_gantt creates a visual representation to help analyze Verilator
 
 For documentation see
 https://verilator.org/guide/latest/exe_verilator_gantt.html""",
-    epilog=
-    """Copyright 2018-2023 by Wilson Snyder. This program is free software; you
+    epilog="""Copyright 2018-2025 by Wilson Snyder. This program is free software; you
 can redistribute it and/or modify it under the terms of either the GNU
 Lesser General Public License Version 3 or the Perl Artistic License
 Version 2.0.
@@ -492,19 +621,16 @@ Version 2.0.
 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('--no-vcd', help='disable creating vcd', action='store_true')
+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')
 
 Args = parser.parse_args()
 
-process(Args.filename)
+read_data(Args.filename)
+report()
 if not Args.no_vcd:
     write_vcd(Args.vcd)
 

bin/verilator_includer

@@ -1,7 +1,8 @@
 #!/usr/bin/env python3
+# mypy: disallow-untyped-defs
 # pylint: disable=C0114,C0209
 #
-# Copyright 2003-2023 by Wilson Snyder. This program is free software; you
+# Copyright 2003-2025 by Wilson Snyder. This program is free software; you
 # can redistribute it and/or modify the Verilator internals under the terms
 # of either the GNU Lesser General Public License Version 3 or the Perl
 # Artistic License Version 2.0.

bin/verilator_profcfunc

@@ -10,7 +10,7 @@ import re
 ######################################################################
 
 
-def profcfunc(filename):
+def profcfunc(filename: str) -> None:
     funcs = {}
 
     with open(filename, "r", encoding="utf8") as fh:
@@ -26,7 +26,7 @@ def profcfunc(filename):
                 calls = float(match.group(3))
                 func = match.group(4)
                 if func not in funcs:
-                    funcs[func] = {'pct': 0, 'sec': 0, 'calls': 0}
+                    funcs[func] = {'pct': 0.0, 'sec': 0.0, 'calls': 0}
                 funcs[func]['pct'] += pct
                 funcs[func]['sec'] += sec
                 funcs[func]['calls'] += calls
@@ -34,9 +34,8 @@ def profcfunc(filename):
 
             # Older gprofs have no call column for single-call functions
             #                  %time      cumesec   selfsec      {stuff}   name
-            match = re.match(
-                r'^\s*([0-9.]+)\s+[0-9.]+\s+([0-9.]+)\s+[^a-zA-Z_]*([a-zA-Z_].*)$',
-                line)
+            match = re.match(r'^\s*([0-9.]+)\s+[0-9.]+\s+([0-9.]+)\s+[^a-zA-Z_]*([a-zA-Z_].*)$',
+                             line)
             if match:
                 pct = float(match.group(1))
                 sec = float(match.group(2))
@@ -136,33 +135,27 @@ def profcfunc(filename):
 
     design_width = 1
     for func, func_item in vfuncs.items():
-        if design_width < len(func_item['design']):
-            design_width = len(func_item['design'])
+        design_width = max(design_width, len(func_item['design']))
 
     print("Verilog code profile:")
     print("   These are split into three categories:")
     print("      C++:     Time in non-Verilated C++ code")
     print("      Prof:    Time in profile overhead")
-    print("      VBlock:  Time attributable to a block in a" +
-          " Verilog file and line")
-    print("      VCommon: Time in a Verilated module," +
-          " due to all parts of the design")
-    print("      VLib:    Time in Verilated common libraries," +
-          " called by the Verilated code")
+    print("      VBlock:  Time attributable to a block in a" + " Verilog file and line")
+    print("      VCommon: Time in a Verilated module," + " due to all parts of the design")
+    print("      VLib:    Time in Verilated common libraries," + " called by the Verilated code")
     print()
 
     print("  %   cumulative   self              ")
     print((" time   seconds   seconds      calls   %-" + str(design_width) +
            "s  type      filename and line number") % "design")
 
-    cume = 0
-    for func in sorted(vfuncs.keys(),
-                       key=lambda f: vfuncs[f]['sec'],
-                       reverse=True):
+    cume = 0.0
+    for func in sorted(vfuncs.keys(), key=lambda f: vfuncs[f]['sec'], reverse=True):
         cume += vfuncs[func]['sec']
         print(("%6.2f %9.2f %8.2f %10d   %-" + str(design_width) + "s  %s") %
-              (vfuncs[func]['pct'], cume, vfuncs[func]['sec'],
-               vfuncs[func]['calls'], vfuncs[func]['design'], func))
+              (vfuncs[func]['pct'], cume, vfuncs[func]['sec'], vfuncs[func]['calls'],
+               vfuncs[func]['design'], func))
 
 
 ######################################################################
@@ -171,7 +164,7 @@ def profcfunc(filename):
 parser = argparse.ArgumentParser(
     allow_abbrev=False,
     formatter_class=argparse.RawDescriptionHelpFormatter,
-    description="""Read gprof report created with --prof-cfuncs.
+    description="""Read gprof report created with Verilator --prof-cfuncs
 
 Verilator_profcfunc reads a profile report created by gprof.  The names of
 the functions are then transformed, assuming the user used Verilator's
@@ -180,18 +173,14 @@ in each Verilog block.
 
 For documentation see
 https://verilator.org/guide/latest/exe_verilator_profcfunc.html""",
-    epilog=
-    """Copyright 2002-2023 by Wilson Snyder. This program is free software; you
+    epilog="""Copyright 2002-2025 by Wilson Snyder. This program is free software; you
 can redistribute it and/or modify it under the terms of either the GNU
 Lesser General Public License Version 3 or the Perl Artistic License
 Version 2.0.
 
 SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0""")
 
-parser.add_argument('--debug',
-                    action='store_const',
-                    const=9,
-                    help='enable debug')
+parser.add_argument('--debug', action='store_const', const=9, help='enable debug')
 parser.add_argument('filename', help='input gprof output to process')
 
 Args = parser.parse_args()

ci/ci-ccache-maint.bash

@@ -1,29 +0,0 @@
-#!/usr/bin/env bash
-# DESCRIPTION: Verilator: CI ccache maintenance
-#
-# Copyright 2020 by Geza Lore. This program is free software; you
-# can redistribute it and/or modify it under the terms of either the GNU
-# Lesser General Public License Version 3 or the Perl Artistic License
-# Version 2.0.
-#
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-
-################################################################################
-# This script is run in 'before_script', once ccache has been set up.
-################################################################################
-
-set -e
-set -x
-
-# Show version
-ccache --version
-
-# Flush ccache if requested in commit message
-COMMIT="${CI_PULL_REQUEST_SHA:-$CI_COMMIT}"
-if git log --format=%B -n 1 "$COMMIT" | grep -q -i '\[CI\s\+ccache\s\+clear\]'; then
-  echo "Flushing ccache due to commit message"
-  ccache -C
-fi
-
-# Dump stats, then zero stats
-ccache -s -z

ci/ci-install.bash

@@ -27,12 +27,6 @@ fatal() {
   echo "ERROR: $(basename "$0"): $1" >&2; exit 1;
 }
 
-if [ "$CI_M32" = "0" ]; then
-  unset CI_M32
-elif [ "$CI_M32" != "1" ]; then
-  fatal "\$CI_M32 must be '0' or '1'";
-fi
-
 if [ "$CI_OS_NAME" = "linux" ]; then
   MAKE=make
 elif [ "$CI_OS_NAME" = "osx" ]; then
@@ -43,10 +37,17 @@ else
   fatal "Unknown os: '$CI_OS_NAME'"
 fi
 
+if [ "$CI_OS_NAME" = "linux" ]; then
+  # Avoid slow "processing triggers for man db"
+  echo "path-exclude /usr/share/doc/*"  | sudo tee -a /etc/dpkg/dpkg.cfg.d/01_nodoc
+  echo "path-exclude /usr/share/man/*"  | sudo tee -a /etc/dpkg/dpkg.cfg.d/01_nodoc
+  echo "path-exclude /usr/share/info/*" | sudo tee -a /etc/dpkg/dpkg.cfg.d/01_nodoc
+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
 }
@@ -61,29 +62,22 @@ 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" ]; 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" ]; then
-      sudo apt-get install mold ||
-      sudo apt-get install mold
-    fi
-    if [ "$COVERAGE" = 1 ]; then
-      yes yes | sudo cpan -fi Parallel::Forker
-    fi
-    if [ "$CI_M32" = 1 ]; then
-      sudo apt-get install gcc-multilib g++-multilib ||
-      sudo apt-get install gcc-multilib g++-multilib
+    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
   elif [ "$CI_OS_NAME" = "osx" ]; then
     brew update
-    brew install ccache perl gperftools
+    brew install ccache perl gperftools autoconf bison flex help2man
   elif [ "$CI_OS_NAME" = "freebsd" ]; then
     sudo pkg install -y autoconf bison ccache gmake perl5
   else
@@ -91,7 +85,7 @@ if [ "$CI_BUILD_STAGE_NAME" = "build" ]; then
   fi
 
   if [ -n "$CCACHE_DIR" ]; then
-    mkdir -p "$CCACHE_DIR" && ./ci/ci-ccache-maint.bash
+    mkdir -p "$CCACHE_DIR"
   fi
 elif [ "$CI_BUILD_STAGE_NAME" = "test" ]; then
   ##############################################################################
@@ -102,38 +96,31 @@ elif [ "$CI_BUILD_STAGE_NAME" = "test" ]; then
     sudo apt-get update ||
     sudo apt-get update
     # libfl-dev needed for internal coverage's test runs
-    sudo apt-get install gdb gtkwave lcov libfl-dev ccache ||
-    sudo apt-get install gdb gtkwave lcov libfl-dev ccache
-    # Required for test_regress/t/t_dist_attributes.pl
-    if [ "$CI_RUNS_ON" = "ubuntu-22.04" ]; then
-      sudo apt-get install libclang-dev mold ||
-      sudo apt-get install libclang-dev mold
-      pip3 install clang==14.0
+    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
+      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" ]; 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
-    if [ "$CI_M32" = 1 ]; then
-      sudo apt-get install lib32z1-dev gcc-multilib g++-multilib ||
-      sudo apt-get install lib32z1-dev gcc-multilib g++-multilib
-    fi
   elif [ "$CI_OS_NAME" = "osx" ]; then
     brew update
     # brew cask install gtkwave # fst2vcd hangs at launch, so don't bother
-    brew install ccache perl
+    brew install ccache perl jq z3
   elif [ "$CI_OS_NAME" = "freebsd" ]; then
     # fst2vcd fails with "Could not open '<input file>', exiting."
-    sudo pkg install -y ccache gmake perl5 python3
+    sudo pkg install -y ccache gmake perl5 python3 jq z3
   else
     fatal "Unknown os: '$CI_OS_NAME'"
   fi
   # Common installs
-  if [ "$CI_RUNS_ON" != "ubuntu-14.04" ]; then
-    CI_CPAN_REPO=https://cpan.org
-  fi
-  yes yes | sudo cpan -M $CI_CPAN_REPO -fi Parallel::Forker
   install-vcddiff
+  # Workaround -fsanitize=address crash
+  sudo sysctl -w vm.mmap_rnd_bits=28
 else
   ##############################################################################
   # Unknown build stage

ci/ci-pages-notify.bash

@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+# DESCRIPTION: Verilator: CI script for 'pages.yml', notifies PRs
+#
+# Copyright 2025 by Geza Lore. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+#
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+# Notify PRs via comment that their coverage reports are available
+
+# Get the current repo URL - might differ on a fork
+readonly REPO_URL=$(gh repo view --json url --jq .url)
+
+# Create artifacts root directory
+ARTIFACTS_ROOT=artifacts
+mkdir -p ${ARTIFACTS_ROOT}
+
+for RUN_ID in ${COVERAGE_PR_RUN_IDS//,/ }; do
+  echo "@@@ Processing run ${RUN_ID}"
+
+  # Create workflow artifacts directory
+  ARTIFACTS_DIR=${ARTIFACTS_ROOT}/${RUN_ID}
+  mkdir -p ${ARTIFACTS_DIR}
+
+  # Download artifact of this run, if exists
+  gh run download ${RUN_ID} --name coverage-pr-notification --dir ${ARTIFACTS_DIR} || true
+  ls -lsha ${ARTIFACTS_DIR}
+
+  # Move on if no notification is required
+  if [ ! -f ${ARTIFACTS_DIR}/pr-number.txt ]; then
+    echo "No notification found"
+    continue
+  fi
+  echo "Posting notification found"
+
+  cat ${ARTIFACTS_DIR}/body.txt
+  gh pr comment $(cat ${ARTIFACTS_DIR}/pr-number.txt) --body-file ${ARTIFACTS_DIR}/body.txt
+
+  # Get the artifact ID
+  ARTIFACT_ID=$(gh api "repos/{owner}/{repo}/actions/runs/${RUN_ID}/artifacts" --jq '.artifacts[] | select(.name == "coverage-pr-notification") | .id')
+
+  # Delete it, so we only notify once
+  gh api --method DELETE "repos/{owner}/{repo}/actions/artifacts/${ARTIFACT_ID}"
+done

ci/ci-pages.bash

@@ -0,0 +1,171 @@
+#!/usr/bin/env bash
+# DESCRIPTION: Verilator: CI script for 'pages.yml', builds the GitHub Pages
+#
+# Copyright 2025 by Geza Lore. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+#
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+# This scipt build the content of the GitHub Pages for the repository.
+# Currently this only hosts code coverage reports, but it would be possible to
+# add any other contents to the page in parallel here.
+
+# Developer note: You should be able to run this script in your local checkout
+# if you have GitHub CLI (command 'gh') setup, authenticated ('gh auth login'),
+# and have set a default repository ('gh repo set-default').
+
+# Create pages root directory. The contents of this directory will be deployed
+# and served via GitHubPages
+readonly PAGES_ROOT=pages
+mkdir -p ${PAGES_ROOT}
+
+# Get the current repo URL - might differ on a fork
+readonly REPO_URL=$(gh repo view --json url --jq .url)
+
+# Set GITHUB_OUTPUT when run locally for testing
+if [[ -z "$GITHUB_OUTPUT" ]]; then
+  GITHUB_OUTPUT=github-output.txt
+fi
+
+# Populates ${PAGES_ROOT}/coverage-reports
+compile_coverage_reports() {
+  # We will process all runs up to and including this date. This is chosen to be
+  # slightly less than the artifact retention period for simplicity.
+  local OLDEST=$(date --date="28 days ago" --iso-8601=date)
+
+  # Gather all coverage workflow runs within the time window
+  gh run list -w coverage.yml --limit 1000 --created ">=${OLDEST}" --json "databaseId,event,status,conclusion,createdAt,number" > recentRuns.json
+  echo @@@ Recent runs:
+  jq "." recentRuns.json
+
+  # Select completd runs that were not cancelled or skipped, sort by descending run number
+  jq 'sort_by(-.number) | map(select(.status == "completed" and (.conclusion == "success" or .conclusion == "failure")))' recentRuns.json > completedRuns.json
+  echo @@@ Completed with success or failure:
+  jq "." completedRuns.json
+
+  # Create artifacts root directory
+  local ARTIFACTS_ROOT=artifacts
+  mkdir -p ${ARTIFACTS_ROOT}
+
+  # Create coverage reports root directory
+  local COVERAGE_ROOT=${PAGES_ROOT}/coverage-reports
+  mkdir -p ${COVERAGE_ROOT}
+
+  # Create index page contents fragment
+  local CONTENTS=contents.tmp
+  echo > ${CONTENTS}
+
+  # Run IDs of PR jobs processed
+  local PR_RUN_IDS=""
+
+  # Iterate over all unique event types that triggered the workflows
+  for EVENT in $(jq -r 'map(.event) | sort | unique | .[]' completedRuns.json); do
+    echo "@@@ Processing '${EVENT}' runs"
+
+    # Emit section header if a report exists with this event type
+    EMIT_SECTION_HEADER=1
+
+    # For each worfklow run that was triggered by this event type
+    for RUN_ID in $(jq ".[] | select(.event == \"${EVENT}\") |.databaseId" completedRuns.json); do
+      echo "@@@ Processing run ${RUN_ID}"
+
+      # Extract the info of this run
+      jq ".[] | select(.databaseId == $RUN_ID)" completedRuns.json > workflow.json
+      jq "." workflow.json
+
+      # Record run ID of PR job
+      if [[ $EVENT == "pull_request" ]]; then
+        if [[ -z "$PR_RUN_IDS" ]]; then
+          PR_RUN_IDS="$RUN_ID"
+        else
+          PR_RUN_IDS="$PR_RUN_IDS,$RUN_ID"
+        fi
+      fi
+
+      # Create workflow artifacts directory
+      local ARTIFACTS_DIR=${ARTIFACTS_ROOT}/${RUN_ID}
+      mkdir -p ${ARTIFACTS_DIR}
+
+      # Download artifacts of this run, if exists
+      gh run download ${RUN_ID} --name coverage-report --dir ${ARTIFACTS_DIR} || true
+      ls -lsha ${ARTIFACTS_DIR}
+
+      # Move on if no coverage report is available
+      if [ ! -d ${ARTIFACTS_DIR}/report ]; then
+        echo "No coverage report found"
+        continue
+      fi
+      echo "Coverage report found"
+
+      # Emit section header
+      if [[ -n $EMIT_SECTION_HEADER ]]; then
+        unset EMIT_SECTION_HEADER
+        if [[ $EVENT == "pull_request" ]]; then
+          echo "<h4>Patch coverage reports for '${EVENT}' runs:</h4>" >> ${CONTENTS}
+        else
+          echo "<h4>Code coverage reports for '${EVENT}' runs:</h4>" >> ${CONTENTS}
+        fi
+      fi
+
+      # Create pages subdirectory
+      mv ${ARTIFACTS_DIR}/report ${COVERAGE_ROOT}/${RUN_ID}
+
+      # Add index page content
+      local WORKFLOW_CREATED=$(jq -r '.createdAt' workflow.json)
+      local WOFKRLOW_NUMBER=$(jq -r '.number' workflow.json)
+      cat >> ${CONTENTS} <<CONTENTS_TEMPLATE
+        Run <a href="${RUN_ID}/index.html">#${WOFKRLOW_NUMBER}</a>
+        | GitHub: <a href="${REPO_URL}/actions/runs/${RUN_ID}">${RUN_ID}</a>
+        | started at: ${WORKFLOW_CREATED}
+CONTENTS_TEMPLATE
+      if [ -e ${ARTIFACTS_DIR}/pr-number.txt ]; then
+        local PRNUMBER=$(cat ${ARTIFACTS_DIR}/pr-number.txt)
+        echo " | Pull request: <a href=\"${REPO_URL}/pull/${PRNUMBER}\">#${PRNUMBER}</a>" >> ${CONTENTS}
+      fi
+      echo "<br>" >> ${CONTENTS}
+    done
+
+    # Section break
+    if [[ -z "$EMIT_SECTION_HEADER" ]]; then
+      echo "<hr>" >> ${CONTENTS}
+    fi
+  done
+
+  # Write coverage report index.html
+  cat > ${COVERAGE_ROOT}/index.html  <<INDEX_TEMPLATE
+  <html>
+
+  <head>
+    <title>Verilator CI coverage reports</title>
+    <style>
+    body {
+      font-family: courier, serif;
+      background-color: #f3f3f3;
+      a {
+        color: #008fd7;
+      }
+    }
+    </style>
+  </head>
+
+  <body>
+  $(cat ${CONTENTS})
+  <h4>Assembled $(date --iso-8601=minutes --utc)</h1>
+  <body>
+
+  </html>
+INDEX_TEMPLATE
+
+  # Report size
+  du -shc ${COVERAGE_ROOT}/*
+
+  # Set output
+  echo "coverage-pr-run-ids=${PR_RUN_IDS}" >> $GITHUB_OUTPUT
+}
+
+# Compilie coverage reports
+compile_coverage_reports;
+
+# You can build any other content here to be put under ${PAGES_ROOT}

ci/ci-script.bash

@@ -21,51 +21,54 @@ fatal() {
   echo "ERROR: $(basename "$0"): $1" >&2; exit 1;
 }
 
-if [ "$CI_M32" = "0" ]; then
-  unset CI_M32
-elif [ "$CI_M32" != "1" ]; then
-  fatal "\$CI_M32 must be '0' or '1'";
-fi
-
 if [ "$CI_OS_NAME" = "linux" ]; then
   export MAKE=make
   NPROC=$(nproc)
 elif [ "$CI_OS_NAME" = "osx" ]; then
   export MAKE=make
   NPROC=$(sysctl -n hw.logicalcpu)
+  # Disable ccache, doesn't always work in GitHub Actions
+  export OBJCACHE=
 elif [ "$CI_OS_NAME" = "freebsd" ]; then
   export MAKE=gmake
   NPROC=$(sysctl -n hw.ncpu)
 else
   fatal "Unknown os: '$CI_OS_NAME'"
 fi
+NPROC=$(expr $NPROC '+' 1)
 
 if [ "$CI_BUILD_STAGE_NAME" = "build" ]; then
   ##############################################################################
   # Build verilator
 
-  if [ "$COVERAGE" != 1 ]; then
-    autoconf
-    ./configure --enable-longtests --enable-ccwarn ${CI_M32:+--enable-m32}
-    ccache -z
-    "$MAKE" -j "$NPROC" -k
-    ccache -s
-    if [ "$CI_OS_NAME" = "osx" ]; then
-      file bin/verilator_bin
-      file bin/verilator_bin_dbg
-      md5 bin/verilator_bin
-      md5 bin/verilator_bin_dbg
-      stat bin/verilator_bin
-      stat bin/verilator_bin_dbg
-    fi
-  else
-    nodist/code_coverage --stages 0-2
+  autoconf
+  CONFIGURE_ARGS="--enable-longtests --enable-ccwarn"
+  if [ "$CI_DEV_ASAN" = 1 ]; then
+    CONFIGURE_ARGS="$CONFIGURE_ARGS --enable-dev-asan"
+    CXX="$CXX -DVL_LEAK_CHECKS"
+  fi
+  if [ "$CI_DEV_GCOV" = 1 ]; then
+    CONFIGURE_ARGS="$CONFIGURE_ARGS --enable-dev-gcov"
+  fi
+  ./configure $CONFIGURE_ARGS --prefix="$INSTALL_DIR"
+  ccache -z
+  "$MAKE" -j "$NPROC" -k
+  # 22.04: ccache -s -v
+  ccache -s
+  if [ "$CI_OS_NAME" = "osx" ]; then
+    file bin/verilator_bin
+    file bin/verilator_bin_dbg
+    md5 bin/verilator_bin
+    md5 bin/verilator_bin_dbg
+    stat bin/verilator_bin
+    stat bin/verilator_bin_dbg
   fi
 elif [ "$CI_BUILD_STAGE_NAME" = "test" ]; then
   ##############################################################################
   # Run tests
 
   export VERILATOR_TEST_NO_CONTRIBUTORS=1  # Separate workflow check
+  export VERILATOR_TEST_NO_LINT_PY=1  # Separate workflow check
 
   if [ "$CI_OS_NAME" = "osx" ]; then
     export VERILATOR_TEST_NO_GDB=1  # Pain to get GDB to work on OS X
@@ -89,103 +92,119 @@ elif [ "$CI_BUILD_STAGE_NAME" = "test" ]; then
     export VERILATOR_TEST_NO_GPROF=1 # gprof is a bit different on FreeBSD, disable
   fi
 
-  # Run sanitize on Ubuntu 20.04 only
-  [ "$CI_RUNS_ON" = 'ubuntu-20.04' ] && [ "$CI_M32" = "" ] && sanitize='--sanitize' || sanitize=''
+  TEST_REGRESS=test_regress
+  if [ "$CI_RELOC" == 1 ]; then
+     # Testing that the installation is relocatable.
+     "$MAKE" install
+     mkdir -p "$RELOC_DIR"
+     mv "$INSTALL_DIR" "$RELOC_DIR/relocated-install"
+     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 .
+  fi
 
   # Run the specified test
   ccache -z
   case $TESTS in
     dist-vlt-0)
-      "$MAKE" -C test_regress SCENARIOS="--dist --vlt $sanitize" DRIVER_HASHSET=--hashset=0/3
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--dist --vlt --driver-clean" DRIVER_HASHSET=--hashset=0/4
       ;;
     dist-vlt-1)
-      "$MAKE" -C test_regress SCENARIOS="--dist --vlt $sanitize" DRIVER_HASHSET=--hashset=1/3
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--dist --vlt --driver-clean" DRIVER_HASHSET=--hashset=1/4
       ;;
     dist-vlt-2)
-      "$MAKE" -C test_regress SCENARIOS="--dist --vlt $sanitize" DRIVER_HASHSET=--hashset=2/3
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--dist --vlt --driver-clean" DRIVER_HASHSET=--hashset=2/4
+      ;;
+    dist-vlt-3)
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--dist --vlt --driver-clean" 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
       ;;
-    coverage-all)
-      nodist/code_coverage --stages 1-
+    vltmt-2)
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt --driver-clean" DRIVER_HASHSET=--hashset=2/3
       ;;
     coverage-dist)
-      nodist/code_coverage --stages 1- --scenarios=--dist
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--dist"
       ;;
     coverage-vlt-0)
-      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=0/10
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vlt" DRIVER_HASHSET=--hashset=0/10
       ;;
     coverage-vlt-1)
-      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=1/10
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vlt" DRIVER_HASHSET=--hashset=1/10
       ;;
     coverage-vlt-2)
-      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=2/10
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vlt" DRIVER_HASHSET=--hashset=2/10
       ;;
     coverage-vlt-3)
-      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=3/10
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vlt" DRIVER_HASHSET=--hashset=3/10
       ;;
     coverage-vlt-4)
-      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=4/10
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vlt" DRIVER_HASHSET=--hashset=4/10
       ;;
     coverage-vlt-5)
-      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=5/10
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vlt" DRIVER_HASHSET=--hashset=5/10
       ;;
     coverage-vlt-6)
-      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=6/10
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vlt" DRIVER_HASHSET=--hashset=6/10
       ;;
     coverage-vlt-7)
-      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=7/10
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vlt" DRIVER_HASHSET=--hashset=7/10
       ;;
     coverage-vlt-8)
-      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=8/10
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vlt" DRIVER_HASHSET=--hashset=8/10
       ;;
     coverage-vlt-9)
-      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=9/10
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vlt" DRIVER_HASHSET=--hashset=9/10
       ;;
     coverage-vltmt-0)
-      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=0/10
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt" DRIVER_HASHSET=--hashset=0/10
       ;;
     coverage-vltmt-1)
-      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=1/10
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt" DRIVER_HASHSET=--hashset=1/10
       ;;
     coverage-vltmt-2)
-      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=2/10
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt" DRIVER_HASHSET=--hashset=2/10
       ;;
     coverage-vltmt-3)
-      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=3/10
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt" DRIVER_HASHSET=--hashset=3/10
       ;;
     coverage-vltmt-4)
-      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=4/10
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt" DRIVER_HASHSET=--hashset=4/10
       ;;
     coverage-vltmt-5)
-      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=5/10
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt" DRIVER_HASHSET=--hashset=5/10
       ;;
     coverage-vltmt-6)
-      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=6/10
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt" DRIVER_HASHSET=--hashset=6/10
       ;;
     coverage-vltmt-7)
-      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=7/10
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt" DRIVER_HASHSET=--hashset=7/10
       ;;
     coverage-vltmt-8)
-      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=8/10
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt" DRIVER_HASHSET=--hashset=8/10
       ;;
     coverage-vltmt-9)
-      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=9/10
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt" DRIVER_HASHSET=--hashset=9/10
       ;;
     *)
       fatal "Unknown test: $TESTS"
       ;;
   esac
+
+  # To see load average (1 minute, 5 minute, 15 minute)
+  uptime
+  # 22.04: ccache -s -v
   ccache -s
 
-  # Upload coverage data
-  if [[ $TESTS == coverage-* ]]; then
-    bash <(cat ci/coverage-upload.sh) -f nodist/obj_dir/coverage/app_total.info
-  fi
 else
   ##############################################################################
   # Unknown build stage

ci/ci-win-compile.ps1

@@ -1,13 +1,26 @@
+# DESCRIPTION: Verilator: CI Windows Power Shell - Compile Verilator
+#
+# Copyright 2024 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+#
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+################################################################################
+
+Set-PSDebug -Trace 1
+
 if (-Not (Test-Path $PWD/../.ccache/win_bison.exe)) {
-	git clone --depth 1 https://github.com/lexxmark/winflexbison
-	cd winflexbison
-	mkdir build
-	cd build
-	cmake .. --install-prefix $PWD/../../../.ccache
-	cmake --build . --config Release -j 3
-	cmake --install . --prefix $PWD/../../../.ccache
-	cd ../..
+    git clone --depth 1 https://github.com/lexxmark/winflexbison
+    cd winflexbison
+    mkdir build
+    cd build
+    cmake .. --install-prefix $PWD/../../../.ccache
+    cmake --build . --config Release -j 3
+    cmake --install . --prefix $PWD/../../../.ccache
+    cd ../..
 }
+
 mkdir build
 cd build
 cmake .. --install-prefix $PWD/../install

ci/ci-win-test.ps1

@@ -1,3 +1,16 @@
+# DESCRIPTION: Verilator: CI Windows Power Shell - Verilate a test
+#
+# Copyright 2024 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+#
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+################################################################################
+
+
+Set-PSDebug -Trace 1
+
 cd install
 $Env:VERILATOR_ROOT=$PWD
 cd examples/cmake_tracing_c
@@ -5,6 +18,9 @@ mkdir build
 cd build
 cmake ..
 cmake --build . --config Release -j 3
-Release/example.exe
+
+# TODO put this back in, see issue# 5163
+# Release/example.exe
+
 cd ..
 Remove-Item -path build -recurse

ci/docker/buildenv/Dockerfile

@@ -6,7 +6,17 @@
 # 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 \
+    && useradd -g verilator -m verilator -s /bin/bash \
+    && apt-get update \
+    && apt-get install --no-install-recommends -y sudo \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/* \
+    && echo verilator ALL=\(root\) NOPASSWD:ALL > /etc/sudoers.d/verilator \
+    && chmod 0440 /etc/sudoers.d/verilator
 
 RUN apt-get update \
     && DEBIAN_FRONTEND=noninteractive \
@@ -26,14 +36,16 @@ RUN apt-get update \
                         help2man \
                         libfl2 \
                         libfl-dev \
+                        libclang-rt-18-dev \
                         libgoogle-perftools-dev \
                         libsystemc \
                         libsystemc-dev \
                         numactl \
                         perl \
                         python3 \
+                        python3-distro \
                         wget \
-                        zlibc \
+                        z3 \
                         zlib1g \
                         zlib1g-dev \
     && apt-get clean \
@@ -41,8 +53,6 @@ RUN apt-get update \
 
 WORKDIR /tmp
 
-RUN cpan install -fi Parallel::Forker
-
 RUN git clone https://github.com/veripool/vcddiff.git && \
     make -C vcddiff && \
     cp -p vcddiff/vcddiff /usr/local/bin/vcddiff && \
@@ -52,6 +62,8 @@ COPY build.sh /tmp/build.sh
 
 ENV VERILATOR_AUTHOR_SITE=1
 
+USER verilator
+
 WORKDIR /work
 
 ENTRYPOINT [ "/tmp/build.sh" ]

ci/docker/buildenv/README.rst

@@ -1,6 +1,8 @@
-.. Copyright 2003-2023 by Wilson Snyder.
+.. Copyright 2003-2025 by Wilson Snyder.
 .. SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 
+.. _Verilator Build Docker Container:
+
 Verilator Build Docker Container
 ================================
 
@@ -11,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
@@ -29,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 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
@@ -50,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/buildenv/build.sh

@@ -9,7 +9,6 @@
 
 : "${REPO:=https://github.com/verilator/verilator}"
 : "${REV:=master}"
-: "${CC:=gcc}"
 : "${CXX:=g++}"
 
 SRCS=$PWD/verilator

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
 

ci/docker/run/README.rst

@@ -1,4 +1,4 @@
-.. Copyright 2003-2023 by Wilson Snyder.
+.. Copyright 2003-2025 by Wilson Snyder.
 .. SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 
 Verilator Executable Docker Container
@@ -11,10 +11,11 @@ easily as a docker image, e.g.:
 
    docker run -ti verilator/verilator:latest --version
 
-This will install the container, run the latest Verilator and print
+This will pull the container from `docker hub
+<https://hub.docker.com/r/verilator/verilator>`_, run the latest Verilator and print
 Verilator's version.
 
-Containers are automatically built for all released versions, so you may
+Containers are automatically built and pushed to docker hub for all released versions, so you may
 easily compare results across versions, e.g.:
 
 ::

codecov.yml

@@ -1,38 +0,0 @@
-# DESCRIPTION: codecov.io config
-#
-# Copyright 2020-2023 by Wilson Snyder. This program is free software; you
-# can redistribute it and/or modify it under the terms of either the GNU
-# Lesser General Public License Version 3 or the Perl Artistic License
-# Version 2.0.
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-####################
-# Validate:
-#  curl --data-binary @codecov.yml https://codecov.io/validate
-
-codecov:
-  require_ci_to_pass: no
-
-coverage:
-  precision: 2
-  round: down
-  range: "50...100"
-  ignore:
-    - "ci"
-    - "docs"
-    - "examples"
-    - "include/gtkwave"
-    - "include/vltstd"
-    - "test_regress"
-
-parsers:
-  gcov:
-    branch_detection:
-      conditional: yes
-      loop: yes
-      method: no
-      macro: no
-
-comment:
-  layout: "reach,diff,flags,tree"
-  behavior: default
-  require_changes: yes

configure.ac

@@ -1,16 +1,17 @@
 # DESCRIPTION: Process this file with autoconf to produce a configure script.
 #
-# Copyright 2003-2023 by Wilson Snyder. Verilator is free software; you
+# Copyright 2003-2025 by Wilson Snyder. Verilator is free software; you
 # can redistribute it and/or modify it under the terms of either the GNU Lesser
 # General Public License Version 3 or the Perl Artistic License Version 2.0.
 # SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 
-# When releasing, also update header of Changes file, and CmakeLists.txt,
+# 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.014 2023-08-06],
+AC_INIT([Verilator],[5.042 2025-11-02],
         [https://verilator.org],
         [verilator],[https://verilator.org])
 
@@ -24,6 +25,13 @@ AC_SUBST(PACKAGE_VERSION_NUMBER)
 AC_DEFINE_UNQUOTED([PACKAGE_VERSION_NUMBER_STRING],["$PACKAGE_VERSION_NUMBER"],[Package version as a number])
 VERILATOR_VERSION_INTEGER=`AS_ECHO("$PACKAGE_VERSION") | [sed 's/\([0-9]\)\.\([0-9][0-9][0-9]\) .*/\1\2000/g']`
 AC_SUBST(VERILATOR_VERSION_INTEGER)
+AC_DEFINE_UNQUOTED([PACKAGE_VERSION_STRING_CHAR],
+        [static const char* const PACKAGE_STRING_UNUSED = "$PACKAGE_STRING";],
+        [Package version as a number])
+AC_SUBST(PACKAGE_VERSION_STRING_CHAR)
+
+######################################################################
+## Arguments/flag checking
 
 # Ignore automake flags passed by Ubuntu builds
 AC_ARG_ENABLE([dependency-tracking],
@@ -49,6 +57,22 @@ AC_ARG_ENABLE([partial-static],
                CFG_ENABLE_PARTIAL_STATIC=yes)
 AC_MSG_RESULT($CFG_ENABLE_PARTIAL_STATIC)
 
+# Flag to enable compiling with AddressSanitizer
+AC_MSG_CHECKING(whether to use AddressSanitizer)
+AC_ARG_ENABLE([dev-asan],
+              [AS_HELP_STRING([--enable-dev-asan],
+                              [Enable compiling Verilator with ASAN
+                               AddressSanitizer for memory error detection.
+                               This disables tcmalloc.  Does not affect
+                               Verilated models using ASAN.])],
+              [case "${enableval}" in
+                yes) CFG_WITH_DEV_ASAN=yes ;;
+                no)  CFG_WITH_DEV_ASAN=no ;;
+                *)   AC_MSG_ERROR([bad value '${enableval}' for --enable-dev-asan]) ;;
+               esac],
+               CFG_WITH_DEV_ASAN=no)
+AC_MSG_RESULT($CFG_WITH_DEV_ASAN)
+
 # Flag to enable linking Verilator with tcmalloc if available
 AC_MSG_CHECKING(whether to use tcmalloc)
 AC_ARG_ENABLE([tcmalloc],
@@ -61,35 +85,27 @@ AC_ARG_ENABLE([tcmalloc],
                 *)   AC_MSG_ERROR([bad value '${enableval}' for --enable-tcmalloc]) ;;
                esac],
               [CFG_WITH_TCMALLOC=check;])
-AC_MSG_RESULT($CFG_WITH_TCMALLOC)
+if test "$CFG_WITH_DEV_ASAN" = "yes"; then
+  CFG_WITH_TCMALLOC=no
+  AC_MSG_RESULT("disabled by --enable-dev-asan")
+else
+  AC_MSG_RESULT($CFG_WITH_TCMALLOC)
+fi
 
-# Flag to enable -m32 build
-AC_MSG_CHECKING(whether to use -m32)
-AC_ARG_ENABLE([m32],
-              [AS_HELP_STRING([--enable-m32],
-                              [Use -m32 for all compilation and link,
-                               including Verilator and generated models.])],
-              [case "${enableval}" in
-                yes) CFG_ENABLE_M32=yes ;;
-                no)  CFG_ENABLE_M32=no ;;
-                *)   AC_MSG_ERROR([bad value '${enableval}' for --enable-m32]) ;;
-               esac],
-               CFG_ENABLE_M32=no)
-AC_MSG_RESULT($CFG_ENABLE_M32)
-
-# Flag to enable coverage build
-AC_MSG_CHECKING(whether to build for coverage collection)
-AC_ARG_ENABLE([coverage],
-              [AS_HELP_STRING([--enable-coverage],
-                              [Build Verilator for code coverage collection.
+# Flag to enable code coverage build with gcov
+AC_MSG_CHECKING(whether to build for gcov code coverage collection)
+AC_ARG_ENABLE([dev-gcov],
+              [AS_HELP_STRING([--enable-dev-gcov],
+                              [Build Verilator for code coverage collection with gcov.
                                For developers only.])],
               [case "${enableval}" in
-                yes) CFG_ENABLE_COVERAGE=yes ;;
-                no)  CFG_ENABLE_COVERAGE=no ;;
-                *)   AC_MSG_ERROR([bad value '${enableval}' for --enable-coverage]) ;;
+                yes) CFG_WITH_DEV_GCOV=yes ;;
+                no)  CFG_WITH_DEV_GCOV=no ;;
+                *)   AC_MSG_ERROR([bad value '${enableval}' for --enable-dev-gcov]) ;;
                esac],
-               CFG_ENABLE_COVERAGE=no)
-AC_MSG_RESULT($CFG_ENABLE_COVERAGE)
+               CFG_WITH_DEV_GCOV=no)
+AC_SUBST(CFG_WITH_DEV_GCOV)
+AC_MSG_RESULT($CFG_WITH_DEV_GCOV)
 
 # Special Substitutions - CFG_WITH_DEFENV
 AC_MSG_CHECKING(whether to use hardcoded paths)
@@ -144,6 +160,33 @@ AC_ARG_ENABLE([longtests],
 AC_SUBST(CFG_WITH_LONGTESTS)
 AC_MSG_RESULT($CFG_WITH_LONGTESTS)
 
+AC_CHECK_PROG(HAVE_Z3,z3,yes)
+AC_CHECK_PROG(HAVE_CVC5,cvc5,yes)
+AC_CHECK_PROG(HAVE_CVC4,cvc4,yes)
+
+# Special Substitutions - CFG_WITH_SOLVER
+AC_MSG_CHECKING(for SMT solver)
+AC_ARG_WITH([solver],
+              [AS_HELP_STRING([--with-solver='z3 --in'],
+                              [set default SMT solver for constrained randomization])],
+              [CFG_WITH_SOLVER="${withval}"],
+              [CFG_WITH_SOLVER=no
+               if test "x$HAVE_Z3" = "xyes"; then
+                CFG_WITH_SOLVER="z3 --in"
+               elif test "x$HAVE_CVC5" = "xyes"; then
+                CFG_WITH_SOLVER="cvc5 --incremental"
+               elif test "x$HAVE_CVC4" = "xyes"; then
+                CFG_WITH_SOLVER="cvc4 --lang=smt2 --incremental"
+               fi]
+              )
+AC_SUBST(CFG_WITH_SOLVER)
+AC_MSG_RESULT($CFG_WITH_SOLVER)
+
+######################################################################
+## Compiler checks
+
+AC_MSG_RESULT([compiler CXX inbound is set to... $CXX])
+
 # Compiler flags (ensure they are not empty to avoid configure defaults)
 CFLAGS="$CFLAGS "
 CPPFLAGS="$CPPFLAGS "
@@ -156,8 +199,10 @@ AC_PROG_CXX
 AC_PROG_INSTALL
 
 AC_LANG_PUSH(C++)
-cxx_version=$($CXX --version | head -1)
-AC_MSG_RESULT([compiler is $CXX --version = $cxx_version])
+CFG_CXX_VERSION=`$CXX --version | head -1`
+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])
 AC_RUN_IFELSE(
    [AC_LANG_SOURCE([int main() { return 0; }])],
@@ -170,24 +215,26 @@ if test "x$AR" = "x" ; then
    AC_MSG_ERROR([Cannot find "ar" in your PATH, please install it])
 fi
 
-AC_PATH_PROG(PERL,perl)
+AC_CHECK_PROG(PERL,perl,perl)
 if test "x$PERL" = "x" ; then
    AC_MSG_ERROR([Cannot find "perl" in your PATH, please install it])
 fi
 
-AC_PATH_PROG(PYTHON3,python3)
+AC_CHECK_PROG(PYTHON3,python3,python3)
 if test "x$PYTHON3" = "x" ; then
    AC_MSG_ERROR([Cannot find "python3" in your PATH, please install it])
 fi
+python3_version=$($PYTHON3 --version | head -1)
+AC_MSG_RESULT([$PYTHON3 --version = $python3_version])
 
-AC_PATH_PROG(LEX,flex)
+AC_CHECK_PROG(LEX,flex,flex)
 if test "x$LEX" = "x" ; then
    AC_MSG_ERROR([Cannot find "flex" in your PATH, please install it])
 fi
 flex_version=$($LEX --version | head -1)
 AC_MSG_RESULT([$LEX --version = $flex_version])
 
-AC_PATH_PROG(YACC,bison)
+AC_CHECK_PROG(YACC,bison,bison)
 if test "x$YACC" = "x" ; then
    AC_MSG_ERROR([Cannot find "bison" in your PATH, please install it])
 fi
@@ -276,6 +323,43 @@ AC_DEFUN([_MY_CXX_CHECK_OPT],
     _MY_CXX_CHECK_IFELSE($2, $1="$$1 $2")
    ])
 
+AC_DEFUN([_MY_CXX_CHECK_CORO_SET],
+   [# _MY_CXX_CHECK_CORO_SET(variable,option)
+    # Check if compiler supports coroutines with specific option. If it does,
+    # set variable to option, only if not previously set.
+    # Define HAVE_COROUTINES if supported.
+    if test "$$1" = ""; then
+      if test "$2" != ""; then
+        _my_msg_opt=" with $2"
+      else
+        _my_msg_opt=""
+      fi
+      AC_MSG_CHECKING([whether coroutines are supported by $CXX$_my_msg_opt])
+      ACO_SAVE_CXXFLAGS="$CXXFLAGS"
+      CXXFLAGS="$CXXFLAGS $2"
+      AC_LINK_IFELSE(
+         [AC_LANG_PROGRAM([
+            #if defined(__clang__) && !defined(__cpp_impl_coroutine)
+            #define __cpp_impl_coroutine 1
+            #endif
+            #include <coroutine>
+          ],[[std::coroutine_handle<> h;]])],
+         [_my_result=yes],
+         [AC_LINK_IFELSE(
+             [AC_LANG_PROGRAM(
+                [#include <experimental/coroutine>],
+                [[std::experimental::coroutine_handle<> h;]])],
+             [_my_result=yes],
+             [_my_result=no])])
+      AC_MSG_RESULT($_my_result)
+      CXXFLAGS="$ACO_SAVE_CXXFLAGS"
+      if test "$_my_result" = "yes" ; then
+        $1="$2"
+        AC_DEFINE([HAVE_COROUTINES],[1],[Defined if coroutines are supported by $CXX])
+      fi
+    fi
+  ])
+
 AC_DEFUN([_MY_LDLIBS_CHECK_FLAG],
    [# _MY_LDLIBS_CHECK_FLAG(flag) -- Check if linker supports specific options
     # Set $_my_result appropriately
@@ -315,16 +399,8 @@ AC_DEFUN([_MY_LDLIBS_CHECK_OPT],
     _MY_LDLIBS_CHECK_IFELSE($2, $1="$$1 $2")
    ])
 
-# When using -m32. Check this first as later checks may fail with the -m32 flag.
-if test "$CFG_ENABLE_M32" = "yes"; then
-  _MY_CXX_CHECK_IFELSE(
-    -m32,
-    [CXX="$CXX -m32"],
-    [AC_MSG_ERROR([--enable-m32 was given but compiler does not support -m32])])
-fi
-
-# Similarly, add the coverage flags early as they influence later checks.
-if test "$CFG_ENABLE_COVERAGE" = "yes"; then
+# Add the coverage flags early as they influence later checks.
+if test "$CFG_WITH_DEV_GCOV" = "yes"; then
   _MY_CXX_CHECK_OPT(CXX,--coverage)
   # Otherwise inline may not show as uncovered
   #  If we use this then e.g. verilated.h functions properly show up
@@ -336,11 +412,19 @@ if test "$CFG_ENABLE_COVERAGE" = "yes"; then
   #  _MY_CXX_CHECK_OPT(CXX,-fkeep-inline-functions)
   # Otherwise static may not show as uncovered
   _MY_CXX_CHECK_OPT(CXX,-fkeep-static-functions)
-  # Exceptions can pollute the branch coverage data
-  _MY_CXX_CHECK_OPT(CXX,-fno-exceptions)
-  # Define-out some impossible stuff
+  # Similarly for inline functions. - This is too slow. See Makefile_obj instead.
+  #_MY_CXX_CHECK_OPT(CXX,-fkeep-inline-functions)
+  # Make sure profiling is thread-safe
+  _MY_CXX_CHECK_OPT(CXX,-fprofile-update=atomic)
+  # Ensure data files can be written from parallel runs
+  _MY_CXX_CHECK_OPT(CXX,-fprofile-reproducible=parallel-runs)
+  # Save source files as absolute paths in gcno files
+  _MY_CXX_CHECK_OPT(CXX,-fprofile-abs-path)
+  # Define so compiled code can know
   _MY_CXX_CHECK_OPT(CXX,-DVL_GCOV)
+  AC_DEFINE([HAVE_DEV_GCOV],[1],[Defined if compiled with code coverage collection for gcov])]
 fi
+AC_SUBST(HAVE_DEV_GCOV)
 
 # Compiler flags to enable profiling
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PROFILE,-pg)
@@ -350,7 +434,7 @@ AC_SUBST(CFG_CXXFLAGS_PROFILE)
 # Macros work such that first option that passes is the one we take
 # Currently enable c++17/c++14 due to packaged SystemC dependency
 # c++17 is the newest that Verilator is regularly tested to support
-# c++11 is the oldest that Verilator supports
+# c++14 is the oldest that Verilator supports
 # gnu is required for Cygwin to compile verilated.h successfully
 #_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=gnu++20)
 #_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=c++20)
@@ -358,8 +442,6 @@ _MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=gnu++17)
 _MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=c++17)
 _MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=gnu++14)
 _MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=c++14)
-_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=gnu++11)
-_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=c++11)
 AC_SUBST(CFG_CXXFLAGS_STD_NEWEST)
 
 # Flags for compiling Verilator internals including parser, and Verilated files
@@ -371,40 +453,28 @@ _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_WEXTRA,-Wthread-safety)
 AC_SUBST(CFG_CXXFLAGS_WEXTRA)
 
 # Flags for coroutine support for dynamic scheduling
-_MY_CXX_CHECK_IFELSE(
-  -fcoroutines-ts,
-  [CFG_CXXFLAGS_COROUTINES="-fcoroutines-ts"],
-  [CFG_CXXFLAGS_COROUTINES="-fcoroutines"])
+_MY_CXX_CHECK_CORO_SET(CFG_CXXFLAGS_COROUTINES, "")
+_MY_CXX_CHECK_CORO_SET(CFG_CXXFLAGS_COROUTINES,-fcoroutines-ts)
+_MY_CXX_CHECK_CORO_SET(CFG_CXXFLAGS_COROUTINES,-fcoroutines)
+_MY_CXX_CHECK_CORO_SET(CFG_CXXFLAGS_COROUTINES,-fcoroutines-ts -Wno-deprecated-experimental-coroutine)
+_MY_CXX_CHECK_CORO_SET(CFG_CXXFLAGS_COROUTINES,-std=gnu++20)
 AC_SUBST(CFG_CXXFLAGS_COROUTINES)
-
-# HAVE_COROUTINES
-# Check if coroutines are supported at all
-AC_MSG_CHECKING([whether coroutines are supported by $CXX])
-ACO_SAVE_CXXFLAGS="$CXXFLAGS"
-CXXFLAGS="$CXXFLAGS $CFG_CXXFLAGS_COROUTINES"
-AC_LINK_IFELSE(
-    [AC_LANG_PROGRAM([
-#ifdef __clang__
-#define __cpp_impl_coroutine 1
-#endif
-#include <coroutine>
-    ],[[]])],
-    [_my_result=yes
-     AC_DEFINE([HAVE_COROUTINES],[1],[Defined if coroutines are supported by $CXX])],
-    [AC_LINK_IFELSE(
-        [AC_LANG_PROGRAM([#include <experimental/coroutine>],[[]])],
-        [_my_result=yes
-         AC_DEFINE([HAVE_COROUTINES],[1],[Defined if coroutines are supported by $CXX])],
-        [_my_result=no])])
-AC_MSG_RESULT($_my_result)
-CXXFLAGS="$ACO_SAVE_CXXFLAGS"
 AC_SUBST(HAVE_COROUTINES)
 
 # Flags for compiling Verilator internals including parser always
+if test "$CFG_WITH_DEV_ASAN" = "yes"; then
+  _MY_CXX_CHECK_IFELSE(-fsanitize=address -DVL_ASAN,
+    [CFG_CXXFLAGS_SRC="$CFG_CXXFLAGS_SRC -fsanitize=address -DVL_ASAN"
+     CFG_LDFLAGS_SRC="$CFG_LDFLAGS_SRC -fsanitize=address"
+     AC_DEFINE([HAVE_DEV_ASAN],[1],[Defined if built with AddresSanitizer])]
+  )
+fi
+AC_SUBST(HAVE_DEV_ASAN)
 _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)
@@ -415,16 +485,22 @@ _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-unused)
 AC_SUBST(CFG_CXXFLAGS_PARSER)
 
 # Flags for compiling the debug version of Verilator (in addition to above CFG_CXXFLAGS_SRC)
-if test "$CFG_ENABLE_COVERAGE" = "no"; then # Do not optimize for the coverage build
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_DEBUG,-Og)
+if test "$CFG_WITH_DEV_GCOV" = "no"; then # Do not optimize for the coverage build
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_DBG,-Og)
 fi
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_DEBUG,-ggdb)
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_DEBUG,-gz)
-AC_SUBST(CFG_CXXFLAGS_DEBUG)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_DBG,-ggdb)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_DBG,-gz)
+AC_SUBST(CFG_CXXFLAGS_DBG)
 
 # Flags for linking the debug version of Verilator (in addition to above CFG_LDFLAGS_SRC)
-_MY_LDLIBS_CHECK_OPT(CFG_LDFLAGS_DEBUG,-gz)
-AC_SUBST(CFG_LDFLAGS_DEBUG)
+_MY_LDLIBS_CHECK_OPT(CFG_LDFLAGS_DBG,-gz)
+AC_SUBST(CFG_LDFLAGS_DBG)
+
+# Flags for compiling the optimized version of Verilator (in addition to above CFG_CXXFLAGS_SRC)
+if test "$CFG_WITH_DEV_GCOV" = "no"; then # Do not optimize for the coverage build
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_OPT,-O3)
+fi
+AC_SUBST(CFG_CXXFLAGS_OPT)
 
 # Flags for Verilated makefile
 # For example, -Wno-div-by-zero isn't in 4.1.2
@@ -439,17 +515,25 @@ 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-tautological-bitwise-compare],
+        [-Wno-c++11-narrowing],
+        [-Wno-constant-logical-operand],
+        [-Wno-int-in-bool-context],
+        [-Wno-non-pod-varargs],
         [-Wno-parentheses-equality],
+        [-Wno-shadow],
         [-Wno-sign-compare],
+        [-Wno-subobject-linkage],
+        [-Wno-tautological-bitwise-compare],
+        [-Wno-tautological-compare],
         [-Wno-uninitialized],
+        [-Wno-unused-but-set-parameter],
         [-Wno-unused-but-set-variable],
         [-Wno-unused-parameter],
-        [-Wno-unused-variable],
-        [-Wno-shadow]],[
+        [-Wno-unused-variable]],[
     _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,cflag)
     # CMake will test what flags work itself, so pass all flags through to it
     CFG_CXX_FLAGS_CMAKE="$CFG_CXX_FLAGS_CMAKE cflag"
@@ -479,7 +563,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
@@ -491,6 +575,7 @@ AC_SUBST(CFG_LDFLAGS_VERILATED)
 # pthreads is harmless otherwise.
 CFG_LIBS="$LIBS $CFG_LIBS"
 _MY_LDLIBS_CHECK_OPT(CFG_LIBS, -lpthread)
+_MY_LDLIBS_CHECK_OPT(CFG_LIBS, -latomic)
 
 # Check libraries for MingW
 _MY_LDLIBS_CHECK_OPT(CFG_LIBS, -lbcrypt)
@@ -502,47 +587,46 @@ _MY_LDLIBS_CHECK_IFELSE(
   [if test "$CFG_WITH_TCMALLOC" != "no"; then
     CFG_LIBS="$LTCMALLOC $CFG_LIBS";
     # If using tcmalloc, add some extra options to make the compiler not assume
-    # it is using it's own versions of the standard library functions
+    # it is using its own versions of the standard library functions
     _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-fno-builtin-malloc)
     _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-fno-builtin-calloc)
     _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-fno-builtin-realloc)
     _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-fno-builtin-free)
+    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++11 at least
-#Alternative: AX_CXX_COMPILE_STDCXX([11])
+# Need C++14 at least
+#Alternative: AX_CXX_COMPILE_STDCXX([14])
 AC_DEFUN([_MY_CXX_CHECK_CXX_VER],
-   [# _MY_CXX_CHECK_CXX_VER(flag) -- Check if compiler runs C++11
+   [# _MY_CXX_CHECK_CXX_VER(flag) -- Check if compiler runs C++14
     # Set $_my_result
-    AC_LINK_IFELSE(
+    AC_RUN_IFELSE(
      [AC_LANG_PROGRAM([#include <thread>
-#if (__cplusplus < 201103L)
+#if (__cplusplus < 201402L)
 # error "Too old"
 #endif
-    ], [[ ]])],
-     [_my_result=yes
-      if test -s conftest.err; then
-        if grep -e "$1" conftest.err >/dev/null; then
-          _my_result=no
-        fi
-      fi],
+    ], [[
+     ]])],
+     [_my_result=yes],
+     [_my_result=no],
      [_my_result=no])
    ])
 
 # Add $CFG_CXXFLAGS_STD only if can't compile correctly otherwise,
 # as adding std= when not needed can cause errors with the C++ std library.
 CFG_CXXFLAGS_STD=$CFG_CXXFLAGS_STD_NEWEST
-AC_MSG_CHECKING(whether $CXX supports C++11)
+AC_MSG_CHECKING(whether $CXX supports C++14)
 _MY_CXX_CHECK_CXX_VER()
 AC_MSG_RESULT($_my_result)
 if test "$_my_result" = "no" ; then
    CXXFLAGS="$CXXFLAGS $CFG_CXXFLAGS_STD"
    CFG_CXX_FLAGS_CMAKE="$CFG_CXX_FLAGS_CMAKE $CFG_CXXFLAGS_STD"
-   AC_MSG_CHECKING(whether $CXX supports C++11 with $CFG_CXXFLAGS_STD)
+   AC_MSG_CHECKING(whether $CXX supports C++14 with $CFG_CXXFLAGS_STD)
    _MY_CXX_CHECK_CXX_VER()
    AC_MSG_RESULT($_my_result)
 else
@@ -552,13 +636,28 @@ else
 fi
 if test "$_my_result" = "no" ; then
    AC_MSG_NOTICE([[]])
-   AC_MSG_ERROR([[the $CXX compiler appears to not support C++11.
+   AC_MSG_ERROR([[the $CXX compiler appears to not support C++14.
 
-Verilator requires a C++11 or newer compiler.]])
+Verilator requires a C++14 or newer compiler.]])
 
 fi
 AC_SUBST(CFG_CXXFLAGS_STD)
 
+# Compiler precompiled header options (assumes either gcc or clang++)
+AC_MSG_CHECKING([for $CXX precompile header include option])
+if $CXX --help | grep include-pch >/dev/null 2>/dev/null ; then
+   # clang
+   CFG_CXXFLAGS_PCH_I=-include-pch
+   CFG_GCH_IF_CLANG=.gch
+else
+   # GCC
+   CFG_CXXFLAGS_PCH_I=-include
+   CFG_GCH_IF_CLANG=
+fi
+AC_MSG_RESULT($CFG_CXXFLAGS_PCH_I)
+AC_SUBST(CFG_CXXFLAGS_PCH_I)
+AC_SUBST(CFG_GCH_IF_CLANG)
+
 # Checks for library functions.
 AC_CHECK_MEMBER([struct stat.st_mtim.tv_nsec],
     [AC_DEFINE([HAVE_STAT_NSEC],[1],[Defined if struct stat has st_mtim.tv_nsec])],
@@ -573,7 +672,7 @@ ACO_SAVE_LIBS="$LIBS"
 LIBS="$LIBS -lsystemc"
 AC_LINK_IFELSE(
     [AC_LANG_PROGRAM([[#include <systemc.h>
-                     extern "C" int sc_main(int argc, char* argv[]) {}
+                     extern "C" int sc_main(int argc, char* argv[]) { return 0; }
                      ]],[[sc_version()]])],
     [_my_result=yes
      AC_DEFINE([HAVE_SYSTEMC],[1],[Defined if have SystemC library])],
@@ -584,6 +683,9 @@ AC_SUBST(HAVE_SYSTEMC)
 
 # Checks for system services
 
+######################################################################
+## Output
+
 # Other install directories
 pkgdatadir=${datadir}/verilator
 AC_SUBST(pkgdatadir)

docs/CONTRIBUTING.rst

@@ -7,8 +7,8 @@ This contributing document contains some suggestions that may make
 contributions flow more efficiently.
 
 
-Did you find a bug?
--------------------
+Did you find a Verilator bug?
+-----------------------------
 
 - Please **ensure the bug was not already reported** by searching
   `Verilator Issues <https://verilator.org/issues>`__.
@@ -28,8 +28,8 @@ Did you find a bug?
     <https://github.com/verilator/verilator/blob/master/docs/internals.rst>`__.
 
 
-Did you write a patch that fixes a bug?
----------------------------------------
+Did you write a patch that fixes a Verilator bug?
+-------------------------------------------------
 
 - Please `Open a new Verilator issue <https://verilator.org/issues/new>`__
   if there is not one already describing the bug.
@@ -72,8 +72,8 @@ Did you write a patch that fixes a bug?
 - Most important is we get your patch.
 
 
-Do you have questions?
-----------------------
+Do you have questions on Verilator?
+-----------------------------------
 
 - Please see FAQ section and rest of the `Verilator
   manual <https://verilator.org/verilator_doc.html>`__, or `Verilator

docs/CONTRIBUTORS

@@ -3,52 +3,84 @@ 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
-Ahmed El-Mahmoudy
+أحمد المحمودي (Ahmed El-Mahmoudy)
+Aidan McNay
 Aleksander Kiryk
 Alex Chadwick
-Àlex Torregrosa
+Alex Solomatnikov
 Aliaksei Chapyzhenka
 Ameya Vikram Singh
+Andrea Calabrese
 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
 Chris Randall
+Christian Hecken
+Christopher Taylor
 Chuxuan Wang
+Chykon
+Congcong Cai
 Conor McCullough
 Dan Petrisko
 Daniel Bates
+Danny Oler
+Dave Sargeant
 David Horton
+David Ledger
 David Metz
 David Stanford
 David Turner
+Dercury
+Diego Roux
+Dominick Grochowina
 Don Williamson
 Drew Ranck
 Drew Taussig
 Driss Hafdi
 Edgar E. Iglesias
+Eric Müller
 Eric Rippey
 Ethan Sifferman
 Eyck Jentzsch
+Fabian Keßler-Schulz
 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
 Howard Su
@@ -56,11 +88,15 @@ Huang Rui
 Huanghuang Zhou
 HungMingWu
 HyungKi Jeong
+Ibrahim Burak Yorulmaz
+Igor Zaworski
 Ilya Barkov
 Iru Cai
 Ivan Vnučec
 Iztok Jeras
 Jake Merdich
+Jakub Wasilewski
+James Bailey
 James Hanlon
 James Hutchinson
 James Pallister
@@ -74,12 +110,19 @@ Jesse Taube
 Jevin Sweval
 Jiacheng Qian
 Jiamin Zhu
+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
+Jordan McConnon
 Jose Loyola
 Josep Sans
 Joseph Nwabueze
@@ -87,17 +130,26 @@ Josh Redford
 Julian Daube
 Julie Schwartz
 Julien Margetts
+Justin Thiel
 Kaleb Barrett
 Kamil Rakoczy
 Kanad Kanhere
+Kefa Chen
 Keith Colbert
 Kevin Kiningham
+Kevin Nygaard
 Kritik Bhimani
 Krzysztof Bieganski
 Krzysztof Boronski
 Krzysztof Boroński
+Krzysztof Obłonczek
+Krzysztof Starecki
+Krzysztof Sychla
 Kuba Ober
+Lan Zongwei
 Larry Doolittle
+Liam Braun
+Luca Colagrande
 Ludwig Rogiers
 Lukasz Dalek
 Maarten De Braekeleer
@@ -110,58 +162,91 @@ Marlon James
 Marshal Qiao
 Martin Schmidt
 Martin Stadler
+Mateusz Gancarz
+Matt Stroud
 Matthew Ballance
+Max Wipfli
+Michael Bedford Taylor
+Michael Bikovitsky
 Michael Killough
+Michal Czyz
 Michaël Lefebvre
 Mike Popoloski
 Miodrag Milanović
 Mladen Slijepcevic
 Morten Borup Petersen
 Mostafa Gamal
+Moubarak Jeje
 Nandu Raj
+Natan Kreimer
+Nathan Graybeal
 Nathan Kohagen
 Nathan Myers
+Nick Brereton
+Nolan Poe
 Oleh Maksymenko
 Patrick Stewart
+Paul Bowen-Huggett
+Paul Swirhun
 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
 Pieter Kapsenberg
 Piotr Binkowski
 Qingyao Sun
+Quentin Corradi
 Rafal Kapuscik
+Rasfunk
 Raynard Qiao
+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
+Szymon Gizler
 Sören Tempel
 Teng Huang
 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
+Valentin Atepalikhin
 Varun Koyyalagunta
 Vassilis Papaefstathiou
 Veripool API Bot
@@ -170,6 +255,9 @@ Vito Gamberini
 William D. Jones
 Wilson Snyder
 Xi Zhang
+Yan Xu
+Yangyu Chen
+Yilou Wang
 Yinan Xu
 Yoda Lee
 Yossi Nivin
@@ -178,5 +266,12 @@ Yuri Victorovich
 Yutetsu TAKATSUKASA
 Yves Mathieu
 Zhanglei Wang
+Zhen Yan
+Zhou Shen
+Zhouyi Shen
 Zixi Li
-أحمد المحمودي
+dependabot[bot]
+february cozzocrea
+sumpster
+Àlex Torregrosa
+Ícaro Lima

docs/Makefile

@@ -5,7 +5,7 @@
 #
 # Code available from: https://verilator.org
 #
-# Copyright 2003-2023 by Wilson Snyder. This program is free software; you
+# Copyright 2003-2025 by Wilson Snyder. This program is free software; you
 # can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
@@ -23,9 +23,9 @@ SPHINXBUILD ?= sphinx-build
 SOURCEDIR = guide
 BUILDDIR = _build
 
-SPHINXOPTS ?= -c guide
+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/README.rst

@@ -0,0 +1,21 @@
+Verilator Documentation
+=======================
+
+This folder contains sources for Verilator documentation.
+
+For formatted documentation see:
+
+- `Verilator README <https://github.com/verilator/verilator>`_
+
+- `Verilator installation and package directory structure
+  <https://verilator.org/install>`_
+
+- `Verilator manual (HTML) <https://verilator.org/verilator_doc.html>`_,
+  or `Verilator manual (PDF) <https://verilator.org/verilator_doc.pdf>`_
+
+- `Subscribe to Verilator announcements
+  <https://github.com/verilator/verilator-announce>`_
+
+- `Verilator forum <https://verilator.org/forum>`_
+
+- `Verilator issues <https://verilator.org/issues>`_

docs/bin/vl_sphinx_extract

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
-# pylint: disable=C0112,C0114,C0115,C0116,C0209,C0301,R0201,R0903
+# mypy: disallow-untyped-defs
+# pylint: disable=C0112,C0114,C0115,C0116,C0209,C0301,R0903
 # -*- Python -*- See copyright, etc below
 ######################################################################
 
@@ -11,9 +12,8 @@ import re
 
 class VlSphinxExtract:
     debug = 0
-    SkipBasenames = {}
 
-    def process(self, filename):
+    def process(self, filename: str) -> None:
         with open(filename, "r", encoding="utf8") as fhr:
             fhw = None
             for line in fhr:
@@ -23,9 +23,7 @@ class VlSphinxExtract:
                     outname = match.group(1)
                     print("Writing %s" % outname)
                     fhw = open(outname, "w", encoding="utf8")  # pylint: disable=consider-using-with
-                    fhw.write(
-                        ".. comment: generated by vl_sphinx_extract from " +
-                        filename + "\n")
+                    fhw.write(".. comment: generated by vl_sphinx_extract from " + filename + "\n")
                     fhw.write(".. code-block::\n")
                 elif re.match(r'^[=a-zA-Z0-9_]', line):
                     fhw = None
@@ -39,18 +37,14 @@ parser = argparse.ArgumentParser(
     allow_abbrev=False,
     formatter_class=argparse.RawDescriptionHelpFormatter,
     description="""Read a file and extract documentation data.""",
-    epilog=
-    """ Copyright 2021-2023 by Wilson Snyder.  This package is free software;
+    epilog=""" Copyright 2021-2025 by Wilson Snyder.  This package is free software;
 you can redistribute it and/or modify it under the terms of either the GNU
 Lesser General Public License Version 3 or the Perl Artistic License
 Version 2.0.
 
 SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0""")
 
-parser.add_argument('--debug',
-                    action='store_const',
-                    const=9,
-                    help='enable debug')
+parser.add_argument('--debug', action='store_const', const=9, help='enable debug')
 parser.add_argument('path', help='path to extract from')
 Args = parser.parse_args()
 

docs/bin/vl_sphinx_fix

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+# mypy: disallow-untyped-defs
 # pylint: disable=C0112,C0114,C0115,C0116,C0209,C0301,R0903
 # -*- Python -*- See copyright, etc below
 ######################################################################
@@ -12,20 +13,17 @@ import re
 
 class VlSphinxFix:
     debug = 0
-    SkipBasenames = {}
 
-    def process(self, path):
+    def process(self, path: str) -> None:
         if os.path.isdir(path):
             for basefile in os.listdir(path):
                 file = os.path.join(path, basefile)
-                if ((basefile != ".") and (basefile != "..")
-                        and basefile not in self.SkipBasenames
-                        and not os.path.islink(file)):
+                if ((basefile != ".") and (basefile != "..") and not os.path.islink(file)):
                     self.process(file)
         elif re.search(r'\.(html|tex)$', path):
             self._edit(path)
 
-    def _edit(self, filename):
+    def _edit(self, filename: str) -> None:
         is_html = re.search(r'\.(html)$', filename)
         with open(filename, "r", encoding="utf8") as fhr:
             origfile = fhr.read()
@@ -54,18 +52,14 @@ parser = argparse.ArgumentParser(
     allow_abbrev=False,
     formatter_class=argparse.RawDescriptionHelpFormatter,
     description="""Post-process Sphinx HTML.""",
-    epilog=
-    """ Copyright 2021-2023 by Wilson Snyder.  This package is free software;
+    epilog=""" Copyright 2021-2025 by Wilson Snyder.  This package is free software;
 you can redistribute it and/or modify it under the terms of either the GNU
 Lesser General Public License Version 3 or the Perl Artistic License
 Version 2.0.
 
 SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0""")
 
-parser.add_argument('--debug',
-                    action='store_const',
-                    const=9,
-                    help='enable debug')
+parser.add_argument('--debug', action='store_const', const=9, help='enable debug')
 parser.add_argument('path', help='path to edit')
 Args = parser.parse_args()
 

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_ASSIGNEQEXPR_faulty.rst

@@ -0,0 +1,9 @@
+.. comment: generated by t_lint_assigneqexpr_bad
+.. code-block:: sv
+   :linenos:
+   :emphasize-lines: 3
+
+     assign d_o =  // Note = not == below
+         (
+         c_o = 1  // <--- Warning: ASSIGNEQEXPR
+         ) ? 1 : (

docs/gen/ex_ASSIGNEQEXPR_msg.rst

@@ -0,0 +1,5 @@
+.. comment: generated by t_lint_assigneqexpr_bad
+.. code-block::
+
+   %Warning-ASSIGNEQEXPR: example.v:1:11 Assignment '=' inside expression
+                                                       : ... Was a '==' intended, or suggest use a separate statement

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:3 Unknown verilator comment: '/*verilator lintt_off WIDTH <--- Warning (lint_off misspelled)*/'
+       7 |   /*verilator lintt_off WIDTH <--- Warning (lint_off misspelled)*/
+         |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

docs/gen/ex_DIDNOTCONVERGE_faulty.rst

@@ -2,5 +2,5 @@
 .. code-block:: sv
    :linenos:
 
-      always_comb b = ~a;
-      always_comb a = b;
+     always_comb b = ~a;
+     always_comb a = b;

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)
-   %Error: t/t_lint_didnotconverge_bad.v:7: Settle region did not converge.
+   -V{t#,#}         'stl' region trigger index 0 is active: @([hybrid] a)
+   %Error: t/t_lint_didnotconverge_bad.v:7: Settle region did not converge after 100 tries

docs/gen/ex_DIDNOTCONVERGE_nodbg_msg.rst

@@ -1,4 +1,4 @@
 .. comment: generated by t_lint_didnotconverge_nodbg_bad
 .. code-block::
 
-   %Error: t/t_lint_didnotconverge_bad.v:7: Settle region did not converge.
+   %Error: t/t_lint_didnotconverge_bad.v:7: Settle region did not converge after 100 tries

docs/gen/ex_FUNCTIMECTL_faulty.rst

@@ -0,0 +1,7 @@
+.. comment: generated by t_lint_functimectl_bad
+.. code-block:: sv
+   :linenos:
+   :emphasize-lines: 2
+
+     function void calls_timing_ctl;
+       @e; // <--- Bad IEEE 1800-2023 13.4 time-controlling

docs/gen/ex_FUNCTIMECTL_msg.rst

@@ -0,0 +1,4 @@
+.. comment: generated by t_lint_functimectl_bad
+.. code-block::
+
+   %Error-FUNCTIMECTL: example.v:1:5 Functions cannot contain time-controlling statements (IEEE 1800-2023 13.4)

docs/gen/ex_HIERPARAM_faulty.rst

@@ -0,0 +1,8 @@
+.. comment: generated by t_param_hier_bad
+.. code-block:: sv
+   :linenos:
+   :emphasize-lines: 3
+
+     sub #(.X(MY_X)) u_sub ();
+
+     localparam int SUB_Y = u_sub.Y;  // <--- BAD: IEEE 1800-2023 6.20.2 no hierarchical

docs/gen/ex_HIERPARAM_msg.rst

@@ -0,0 +1,7 @@
+.. comment: generated by t_param_hier_bad
+.. code-block::
+
+   %Error-HIERPARAM: example.v:1:32 Parameter values cannot use hierarchical values (IEEE 1800-2023 6.20.2)
+                                               : ... note: In instance 't'
+      36 |   localparam int SUB_Y = u_sub.Y;
+         |                                ^

docs/gen/ex_MULTIDRIVEN_faulty.rst

@@ -3,9 +3,9 @@
    :linenos:
    :emphasize-lines: 2,5
 
-      always @(posedge clk) begin
-         out2[7:0] <= d0;  // <--- Warning
-      end
-      always @(negedge clk) begin
-         out2[15:8] <= d0;  // <--- Warning
-      end
+     always @(posedge clk) begin
+       out2[7:0] <= d0;  // <--- Warning
+     end
+     always @(negedge clk) begin
+       out2[15:8] <= d0;  // <--- Warning
+     end

docs/gen/ex_MULTIDRIVEN_msg.rst

@@ -1,6 +1,6 @@
 .. comment: generated by t_lint_multidriven_bad
 .. code-block::
 
-   %Warning-MULTIDRIVEN: example.v:1:22 Signal has multiple driving blocks with different clocking: 'out2'
-                         example.v:1:7 ... Location of first driving block
-                         example.v:1:7 ... Location of other driving block
+   %Warning-MULTIDRIVEN: example.v:1:21 Signal has multiple driving blocks with different clocking: 'out2'
+                         example.v:1:5 ... Location of first driving block
+                         example.v:1:5 ... Location of other driving block

docs/gen/ex_NORETURN_faulty.rst

@@ -0,0 +1,7 @@
+.. comment: generated by t_lint_noreturn_bad
+.. code-block:: sv
+   :linenos:
+   :emphasize-lines: 1
+
+     function int no_rtn();  // <--- Warning: No return
+     endfunction

docs/gen/ex_NORETURN_msg.rst

@@ -0,0 +1,4 @@
+.. comment: generated by t_lint_noreturn_bad
+.. code-block::
+
+   %Warning-NORETURN: example.v:1:16 Non-void function 'no_rtn' has no return value

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_faulty.rst

@@ -0,0 +1,11 @@
+.. comment: generated by t_lint_pinmissing_bad
+.. code-block:: sv
+   :linenos:
+   :emphasize-lines: 2
+
+   module t;
+      sub sub();  // <--- Warning
+   endmodule
+   module sub
+     (output port);
+   endmodule

docs/gen/ex_PINMISSING_msg.rst

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

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:20 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:7 ... Location of variable process write
+                                                        : ... Perhaps should initialize instead using a reset in this process
+      30 |       flop_out <= ~in;
+         |       ^~~~~~~~

docs/gen/ex_STMTDLY_faulty.rst

@@ -2,4 +2,4 @@
 .. code-block:: sv
    :emphasize-lines: 1
 
-         #100 $finish;  //<--- Warning
+       #100 $finish;  //<--- Warning

docs/gen/ex_STMTDLY_msg.rst

@@ -1,4 +1,4 @@
 .. comment: generated by t_lint_stmtdly_bad
 .. code-block::
 
-   %Warning-STMTDLY: example.v:1:7 Ignoring delay on this statement due to --no-timing
+   %Warning-STMTDLY: example.v:1:5 Ignoring delay on this statement due to --no-timing

docs/gen/ex_USERERROR_faulty.rst

@@ -1,4 +1,4 @@
 .. comment: generated by t_assert_comp_bad
 .. code-block:: sv
 
-         $error("User elaboration-time error");
+       $error("User elaboration-time error");

docs/gen/ex_USERERROR_msg.rst

@@ -1,4 +1,4 @@
 .. comment: generated by t_assert_comp_bad
 .. code-block::
 
-   %Warning-USERERROR: example.v:1:7 User elaboration-time error
+   %Warning-USERERROR: example.v:1:5 User elaboration-time error

docs/gen/ex_USERFATAL_faulty.rst

@@ -1,4 +1,4 @@
 .. comment: generated by t_assert_comp_bad
 .. code-block:: sv
 
-         $fatal(0, "User elaboration-time fatal");
+       $fatal(0, "User elaboration-time fatal");

docs/gen/ex_USERFATAL_msg.rst

@@ -1,4 +1,4 @@
 .. comment: generated by t_assert_comp_bad
 .. code-block::
 
-   %Warning-USERFATAL: example.v:1:7 User elaboration-time fatal
+   %Warning-USERFATAL: example.v:1:5 User elaboration-time fatal

docs/gen/ex_USERINFO_faulty.rst

@@ -1,4 +1,4 @@
 .. comment: generated by t_assert_comp_bad
 .. code-block:: sv
 
-         $info("User elaboration-time info");
+       $info("User elaboration-time info");

docs/gen/ex_USERINFO_msg.rst

@@ -1,4 +1,4 @@
 .. comment: generated by t_assert_comp_bad
 .. code-block::
 
-   -Info: example.v:1:7 User elaboration-time info
+   -Info: example.v:1:5 User elaboration-time info

docs/gen/ex_USERWARN_faulty.rst

@@ -1,4 +1,4 @@
 .. comment: generated by t_assert_comp_bad
 .. code-block:: sv
 
-         $warning("User elaboration-time warning");
+       $warning("User elaboration-time warning");

docs/gen/ex_USERWARN_msg.rst

@@ -1,4 +1,4 @@
 .. comment: generated by t_assert_comp_bad
 .. code-block::
 
-   %Warning-USERWARN: example.v:1:7 User elaboration-time warning
+   %Warning-USERWARN: example.v:1:5 User elaboration-time warning

docs/gen/ex_VARHIDDEN_faulty.rst

@@ -4,5 +4,5 @@
    :emphasize-lines: 2
 
    module t;
-      integer t;  //<--- Warning ('t' hidden by module 't')
+     integer t;  //<--- Warning ('t' hidden by module 't')
    endmodule

docs/gen/ex_VARHIDDEN_msg.rst

@@ -1,5 +1,5 @@
 .. comment: generated by t_var_bad_hide_docs
 .. code-block::
 
-   %Warning-VARHIDDEN: example.v:2:12 Declaration of signal hides declaration in upper scope: 't'
+   %Warning-VARHIDDEN: example.v:2:11 Declaration of signal hides declaration in upper scope: 't'
                        example.v:1:8 ... Location of original declaration

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