Commentary - update version date

.bake.toml

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

.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

@@ -1,20 +0,0 @@
----
-# DESCRIPTION: codecov.io config
-#
-# Copyright 2020-2026 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

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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,20 @@
+---
+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' command line do we use to run your example?
+
+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

@@ -0,0 +1,16 @@
+---
+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

@@ -1,24 +0,0 @@
----
-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,5 +8,3 @@ 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

@@ -1,8 +0,0 @@
----
-# 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

@@ -1,286 +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-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@v6
-        with:
-          path: repo
-      - name: Cache $CCACHE_DIR
-        uses: actions/cache@v5
-        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@v6
-        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

@@ -0,0 +1,169 @@
+# 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
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name == 'pull_request' && github.ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-22.04, ubuntu-20.04]
+        compiler:
+          - { cc: clang, cxx: clang++ }
+          - { cc: gcc,   cxx: g++     }
+        include:
+          # Build GCC 10 on ubuntu-20.04
+          - os: ubuntu-20.04
+            compiler: { cc: gcc-10, cxx: g++-10 }
+    runs-on: ${{ matrix.os }}
+    name: Build | ${{ matrix.os }} | ${{ matrix.compiler.cc }}
+    env:
+      CI_BUILD_STAGE_NAME: build
+      CI_RUNS_ON: ${{ matrix.os }}
+      CC: ${{ matrix.compiler.cc }}
+      CXX: ${{ matrix.compiler.cxx }}
+      CACHE_BASE_KEY: build-${{ matrix.os }}-${{ matrix.compiler.cc }}
+      CCACHE_MAXSIZE: 1000M # Per build matrix entry (* 5 = 5000M in total)
+      VERILATOR_ARCHIVE: verilator-${{ github.sha }}-${{ matrix.os }}-${{ matrix.compiler.cc }}.tar.gz
+    steps:
+
+    - name: Checkout
+      uses: actions/checkout@v4
+      with:
+        path: repo
+
+    - name: Cache $CCACHE_DIR
+      uses: actions/cache@v4
+      env:
+        CACHE_KEY: ${{ env.CACHE_BASE_KEY }}-ccache
+      with:
+        path: ${{ env.CCACHE_DIR }}
+        key: ${{ env.CACHE_KEY }}-${{ github.sha }}
+        restore-keys: |
+          ${{ env.CACHE_KEY }}-
+
+    - name: Install packages for build
+      run: ./ci/ci-install.bash
+
+    - name: Build
+      run: ./ci/ci-script.bash
+
+    - name: Tar up repository
+      working-directory: ${{ github.workspace }}
+      run: tar --posix -c -z -f ${{ env.VERILATOR_ARCHIVE }} repo
+
+    - name: Upload tar archive
+      uses: actions/upload-artifact@v4
+      with:
+        path: ${{ github.workspace }}/${{ env.VERILATOR_ARCHIVE }}
+        name: ${{ env.VERILATOR_ARCHIVE }}
+
+
+  test:
+    needs: build
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-22.04, ubuntu-20.04]
+        compiler:
+          - { cc: clang, cxx: clang++ }
+          - { cc: gcc,   cxx: g++     }
+        suite: [dist-vlt-0, dist-vlt-1, dist-vlt-2, vltmt-0, vltmt-1]
+        include:
+          # Test with GCC 10 on ubuntu-20.04
+          - {os: ubuntu-20.04, compiler: { cc: gcc-10, cxx: g++-10 }, suite: dist-vlt-0}
+          - {os: ubuntu-20.04, compiler: { cc: gcc-10, cxx: g++-10 }, suite: dist-vlt-1}
+          - {os: ubuntu-20.04, compiler: { cc: gcc-10, cxx: g++-10 }, suite: dist-vlt-2}
+          - {os: ubuntu-20.04, compiler: { cc: gcc-10, cxx: g++-10 }, suite: vltmt-0}
+          - {os: ubuntu-20.04, compiler: { cc: gcc-10, cxx: g++-10 }, suite: vltmt-1}
+    runs-on: ${{ matrix.os }}
+    name: Test | ${{ matrix.os }} | ${{ matrix.compiler.cc }} | ${{ matrix.suite }}
+    env:
+      CI_BUILD_STAGE_NAME: test
+      CI_RUNS_ON: ${{ matrix.os }}
+      CC: ${{ matrix.compiler.cc }}
+      CXX: ${{ matrix.compiler.cxx }}
+      CACHE_BASE_KEY: test-${{ matrix.os }}-${{ matrix.compiler.cc }}-${{ matrix.suite }}
+      CCACHE_MAXSIZE: 100M # Per build per suite (* 5 * 5 = 2500M in total)
+      VERILATOR_ARCHIVE: verilator-${{ github.sha }}-${{ matrix.os }}-${{ matrix.compiler.cc }}.tar.gz
+    steps:
+
+    - name: Download tar archive
+      uses: actions/download-artifact@v4
+      with:
+        name: ${{ env.VERILATOR_ARCHIVE }}
+        path: ${{ github.workspace }}
+
+    - name: Unpack tar archive
+      working-directory: ${{ github.workspace }}
+      run: tar -x -z -f ${{ env.VERILATOR_ARCHIVE }}
+
+    - name: Cache $CCACHE_DIR
+      uses: actions/cache@v4
+      env:
+        CACHE_KEY: ${{ env.CACHE_BASE_KEY }}-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
+
+  lint-py:
+    runs-on: ubuntu-22.04
+    name: Lint Python
+    env:
+      CI_BUILD_STAGE_NAME: build
+      CI_RUNS_ON: ubuntu-22.04
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+      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 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/contributor.yml

@@ -1,20 +1,17 @@
----
 # 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-24.04
+    runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v6
-      - run: test_regress/t/t_dist_contributors.py
+    - uses: actions/checkout@v4
+    - run: test_regress/t/t_dist_contributors.pl

.github/workflows/coverage.yml

@@ -1,213 +1,98 @@
----
 # DESCRIPTION: Github actions config
 # SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 
-name: Code coverage
+name: coverage
 
 on:
   workflow_dispatch:
   schedule:
-    - cron: '0 0 * * 0'  # weekly
-  pull_request:
-    types: [opened, synchronize, reopened, labeled, unlabeled]
+  - cron: '0 0 * * 0' # weekly
 
-permissions:
-  contents: read
+env:
+  CI_OS_NAME: linux
+  CI_COMMIT: ${{ github.sha }}
+  COVERAGE: 1
+  VERILATOR_ARCHIVE: verilator-coverage-${{ github.sha }}.tar.gz
 
 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' }}
+    working-directory: repo
 
 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
 
-  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
+  Build:
+    runs-on: ubuntu-22.04
+    env:
+      CI_BUILD_STAGE_NAME: build
+      CI_RUNS_ON: ubuntu-22.04
+    steps:
+
+    - name: Checkout
+      uses: actions/checkout@v4
+      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@v4
+      with:
+        path: ${{ github.workspace }}/${{ env.VERILATOR_ARCHIVE }}
+        name: ${{ env.VERILATOR_ARCHIVE }}
+
+
+  Test:
+    needs: Build
     strategy:
       fail-fast: false
       matrix:
-        test: [coverage-vlt-, coverage-vltmt-]
-        num: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+        test:
+        - vlt-
+        - vltmt-
+        num:
+        - 0
+        - 1
+        - 2
+        - 3
+        - 4
+        - 5
+        - 6
+        - 7
+        - 8
+        - 9
         include:
-          - {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
+        - { 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
     steps:
-      - name: Checkout
-        uses: actions/checkout@v6
 
-      - name: Download code coverage data
-        uses: actions/download-artifact@v7
-        with:
-          pattern: code-coverage-*
-          path: obj_coverage
-          merge-multiple: true
+    - name: Download tar archive
+      uses: actions/download-artifact@v4
+      with:
+        name: ${{ env.VERILATOR_ARCHIVE }}
+        path: ${{ github.workspace }}
 
-      - name: List files
-        id: list-files
-        run: |
-          ls -lsha obj_coverage
-          find obj_coverage -type f | paste -sd, | sed "s/^/files=/" >> "$GITHUB_OUTPUT"
+    - name: Unpack tar archive
+      working-directory: ${{ github.workspace }}
+      run: tar -x -z -f ${{ env.VERILATOR_ARCHIVE }}
 
-      - 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: Install test dependencies
+      run: ./ci/ci-install.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@v7
-        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@v7
-        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@v6
-        with:
-          path: repo/obj_coverage
-          name: coverage-report
-
-      - name: Upload notification
-        if: ${{ github.event_name == 'pull_request' }}
-        uses: actions/upload-artifact@v6
-        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
+    - name: Test
+      env:
+        TESTS: coverage-${{ matrix.test }}${{ matrix.num }}
+      run: ./ci/ci-script.bash

.github/workflows/docker.yml

@@ -1,4 +1,3 @@
----
 # Build and push verilator docker image when tags are pushed to the repository.
 # The following variable(s) must be configured in the github repository:
 # DOCKER_HUB_NAMESPACE: docker hub namespace.
@@ -9,7 +8,7 @@ name: Build Verilator Container
 
 on:
   push:
-    tags: ['v*']
+    tags: [ 'v*' ]
   workflow_dispatch:
     inputs:
       manual_tag:
@@ -22,14 +21,11 @@ on:
         type: boolean
         default: false
 
-permissions:
-  contents: write
-
 jobs:
 
   build:
 
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04
 
     strategy:
       matrix:
@@ -38,52 +34,52 @@ jobs:
           # - "ci/docker/buildenv:verilator-buildenv"
 
     steps:
-      - name: Checkout
-        uses: actions/checkout@v6
+    - name: Checkout
+      uses: actions/checkout@v4
 
-      - 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@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: Docker meta
+      id: docker_meta
+      uses: docker/metadata-action@v4
+      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@v3
+    - name: Set up QEMU
+      uses: docker/setup-qemu-action@v2
 
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-        with:
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v2
+      with:
           buildkitd-flags: --debug
 
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKER_HUB_USER }}
-          password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
+    - name: Login to Docker Hub
+      uses: docker/login-action@v2
+      with:
+        username: ${{ secrets.DOCKER_HUB_USER }}
+        password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
 
-      - 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 }}
+    - 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 }}

.github/workflows/format.yml

@@ -1,46 +1,42 @@
----
 # DESCRIPTION: Github actions config
 # SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-#
+
 name: format
+
 on:
   push:
-    branches-ignore:
-      - 'dependabot/**'  # Avoid duplicates: only run the PR, not the push
-
-permissions:
-  contents: write
+  pull_request_target:
+  workflow_dispatch:
 
 jobs:
   format:
-    runs-on: ubuntu-24.04
-    name: Ubuntu 24.04 | format
+    runs-on: ubuntu-22.04
+    name: Ubuntu 22.04 | format
     env:
       CI_OS_NAME: linux
-      CI_RUNS_ON: ubuntu-24.04
+      CI_RUNS_ON: ubuntu-22.04
       CI_COMMIT: ${{ github.sha }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
       - name: Install packages for build
         env:
           CI_BUILD_STAGE_NAME: build
         run: |
-          sudo apt install clang-format-18
-          git config --global user.email "[email protected]"
+          bash ci/ci-install.bash &&
+          sudo apt-get install clang-format-14 yapf3 &&
+          git config --global user.email "[email protected]" &&
           git config --global user.name "github action"
       - name: Format code
         run: |
-          autoconf
-          ./configure
-          make venv
-          source .venv/bin/activate
-          make -j 2 format CLANGFORMAT=clang-format-18
+          autoconf &&
+          ./configure &&
+          make -j 2 format CLANGFORMAT=clang-format-14 &&
           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

@@ -0,0 +1,55 @@
+# 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
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name == 'pull_request' && github.ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+
+   windows:
+    name: run on windows
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v4
+      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@v4
+      with:
+        path: ${{ github.workspace }}/repo/verilator.zip
+        name: verilator-win.zip

.github/workflows/pages.yml

@@ -1,87 +0,0 @@
----
-# 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@v6
-      - 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@v6
-      # 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

@@ -1,99 +0,0 @@
----
-# 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@v6
-        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@v5
-        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@v6
-        with:
-          path: ${{ github.workspace }}/${{ steps.create-archive.outputs.archive }}
-          name: ${{ steps.create-archive.outputs.archive }}

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

@@ -1,50 +0,0 @@
----
-# 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@v6
-        with:
-          path: repo
-
-      - name: Install packages for build
-        run: ./ci/ci-install.bash
-
-      - name: Configure
-        run: |
-          autoconf
-          ./configure --enable-longtests --enable-ccwarn
-
-      - name: Install python dependencies
-        run: |
-          sudo apt install python3-clang
-          make venv
-
-      - name: Lint
-        run: |-
-          source .venv/bin/activate
-          make -k lint-py

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

@@ -1,75 +0,0 @@
----
-# 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@v5
-        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@v6
-        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@v6
-        with:
-          path: verilator-rtlmeter.tar.gz
-          name: verilator-rtlmeter-${{ inputs.runs-on }}-${{ inputs.cc }}
-          overwrite: true

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

@@ -1,128 +0,0 @@
----
-# 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@v7
-        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@v5
-        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@v6
-        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@v6
-        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

@@ -1,109 +0,0 @@
----
-# 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@v7
-        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@v5
-        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
-          make venv
-
-      - name: Test
-        id: run-test
-        continue-on-error: true
-        env:
-          TESTS: ${{ inputs.suite }}
-        run: |
-          source .venv/bin/activate
-          ./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@v6
-        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

@@ -1,48 +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: 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@v7
-        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@v7
-        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

@@ -1,418 +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: 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:*"
-          - "Caliptra:default:*"
-          - "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:*"
-          - "Caliptra:default:*"
-          - "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@v6
-        with:
-          repository: "verilator/rtlmeter"
-          path: rtlmeter
-      - name: Setup RTLMeter venv
-        working-directory: rtlmeter
-        run: make venv
-      - name: Download all results
-        uses: actions/download-artifact@v7
-        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@v6
-        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@v7
-        with:
-          pattern: all-results-*
-          path: results
-          merge-multiple: true
-      - name: Upload published results
-        uses: actions/upload-artifact@v6
-        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@v6
-        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@v6
-        with:
-          repository: "verilator/rtlmeter"
-          path: rtlmeter
-      - name: Setup RTLMeter venv
-        working-directory: rtlmeter
-        run: make venv
-      - name: Download combined results
-        uses: actions/download-artifact@v7
-        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@v7
-        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@v6
-        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@v6
-        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

@@ -17,7 +17,6 @@
 *.pdf
 /Makefile
 /.ccache
-/.venv/
 /artifact/
 README
 TAGS
@@ -30,25 +29,18 @@ dddrun*
 doxygen-doc
 gdbrun*
 gmon.out
-internals.txt
 ncverilog.history
-nohup.out
-verilator-config-version.cmake
-verilator-config.cmake
-verilator.pc
+internals.txt
 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

@@ -1,8 +0,0 @@
----
-- 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

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

CITATION.cff

@@ -1,28 +0,0 @@
----
-# 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
-  - given-names: Geza
-    family-names: Lore
-  - 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 only a
-  traditional simulator but a compiler.
-license: [LGPL-3.0-only, Artistic-2.0]

CMakeLists.txt

@@ -4,7 +4,7 @@
 #
 #*****************************************************************************
 #
-# Copyright 2003-2026 by Wilson Snyder. This program is free software; you
+# Copyright 2003-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.
@@ -14,54 +14,36 @@
 
 cmake_minimum_required(VERSION 3.15)
 cmake_policy(SET CMP0091 NEW) # Use MSVC_RUNTIME_LIBRARY to select the runtime
-project(
-    Verilator
-    VERSION 5.044
+project(Verilator
+    VERSION 5.022
     HOMEPAGE_URL https://verilator.org
     LANGUAGES CXX
 )
 
-# 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."
-)
+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_EXECUTABLE})
-# See also CMake built-in; CMAKE_INSTALL_PREFIX is applied by the install command.
-set(CMAKE_INSTALL_DATADIR .)
+set(PYTHON3 Python3::Interpreter)
+set(CMAKE_INSTALL_DATADIR ${CMAKE_INSTALL_PREFIX})
 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(WIN32)
-    if(DEFINED ENV{WIN_FLEX_BISON})
+if (WIN32)
+    if (DEFINED ENV{WIN_FLEX_BISON})
         set(WIN_FLEX_BISON "$ENV{WIN_FLEX_BISON}")
     endif()
-    if(IS_DIRECTORY ${WIN_FLEX_BISON})
+    if (EXISTS ${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()
@@ -69,25 +51,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 "")
+if (OBJCACHE_ENABLED)
+    if (OBJCACHE STREQUAL "")
         find_program(OBJCACHE_PATH ccache)
-        if(OBJCACHE_PATH STREQUAL "OBJCACHE_PATH-NOTFOUND")
+        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
-        )
+    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}\")"
-        )
+        message(STATUS "Found ccache: ${OBJCACHE_PATH} (\"${objcache_version}\")")
         set(CMAKE_CXX_COMPILER_LAUNCHER "${OBJCACHE_PATH}")
     endif()
 endif()
@@ -98,8 +75,8 @@ 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})
@@ -118,69 +95,44 @@ 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 include
-)
-install(
-    FILES ${CMAKE_CURRENT_BINARY_DIR}/include/verilated.mk
-    DESTINATION include
+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}
 )
 
-configure_package_config_file(
-    verilator-config.cmake.in
-    verilator-config.cmake
-    INSTALL_DESTINATION .
+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}
 )
 
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/verilator-config.cmake DESTINATION .)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/verilator-config-version.cmake DESTINATION ${CMAKE_INSTALL_PREFIX})
 
-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
+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-2026 by Wilson Snyder. This program is free software; you
+# Copyright 2003-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.
@@ -52,7 +52,6 @@ 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)
@@ -77,7 +76,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@
 
@@ -91,68 +90,62 @@ 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/json_py \
+	examples/cmake_hello_c \
+	examples/cmake_hello_sc \
+	examples/cmake_tracing_c \
+	examples/cmake_tracing_sc \
+	examples/cmake_protect_lib \
+	examples/make_hello_binary \
+	examples/make_hello_c \
+	examples/make_hello_sc \
+	examples/make_tracing_c \
+	examples/make_tracing_sc \
+	examples/make_protect_lib \
+	examples/json_py \
 
 INFOS = verilator.html verilator.pdf
 
 INFOS_OLD = README README.html README.pdf
 
 EXAMPLES_FIRST = \
-  examples/make_hello_c \
-  examples/make_hello_sc \
+	examples/make_hello_c \
+	examples/make_hello_sc \
 
 EXAMPLES = $(EXAMPLES_FIRST) $(filter-out $(EXAMPLES_FIRST), $(sort $(wildcard examples/*)))
 
 # See uninstall also - don't put wildcards in this variable, it might uninstall other stuff
 # No verilator_ccache_report.1, verilator_difftree.1 as those are not bin/ installed
 VL_INST_MAN_FILES = \
-  verilator.1 \
-  verilator_coverage.1 \
-  verilator_gantt.1 \
-  verilator_profcfunc.1 \
+	verilator.1 \
+	verilator_coverage.1 \
+	verilator_gantt.1 \
+	verilator_profcfunc.1 \
 
 default: all
 all: all_nomsg msg_test
 all_nomsg: verilator_exe $(VL_INST_MAN_FILES)
 
-.PHONY: verilator_exe
-.PHONY: verilator_bin$(EXEEXT)
-.PHONY: verilator_bin_dbg$(EXEEXT)
-.PHONY: verilator_coverage_bin_dbg$(EXEEXT)
+.PHONY:verilator_exe
+.PHONY:verilator_bin$(EXEEXT)
+.PHONY:verilator_bin_dbg$(EXEEXT)
+.PHONY:verilator_coverage_bin_dbg$(EXEEXT)
 verilator_exe verilator_bin$(EXEEXT) verilator_bin_dbg$(EXEEXT) verilator_coverage_bin_dbg$(EXEEXT):
 	@echo ------------------------------------------------------------
 	@echo "making verilator in src"
 	$(MAKE) -C src $(OBJCACHE_JOBS)
 
-######################################################################
-# Tests
-
-.PHONY: msg_test
+.PHONY:msg_test
 msg_test: all_nomsg
 	@echo "Build complete!"
 	@echo
@@ -162,7 +155,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.py
+# examples is part of test_regress's test_regress/t/t_a2_examples.pl
 # (because that allows it to run in parallel with other test_regress's)
 else
 test: smoke-test examples
@@ -174,8 +167,8 @@ endif
 	@echo
 
 smoke-test: all_nomsg
-	test_regress/t/t_a1_first_cc.py
-	test_regress/t/t_a2_first_sc.py
+	test_regress/t/t_a1_first_cc.pl
+	test_regress/t/t_a2_first_sc.pl
 
 test_regress: all_nomsg
 	$(MAKE) -C test_regress
@@ -186,14 +179,11 @@ test-snap test-diff:
 
 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 $(VL_INST_MAN_FILES)
+docs: info
 
 info: $(INFOS)
 
@@ -202,8 +192,7 @@ verilator.1: ${srcdir}/bin/verilator
 verilator_coverage.1: ${srcdir}/bin/verilator_coverage
 	pod2man $< $@
 %.1: ${srcdir}/bin/%
-	help2man --no-info --no-discard-stderr --version-string=- \
-		-n "$(shell $< --help | head -n 3 | tail -n 1)" $< -o $@
+	help2man --no-info --no-discard-stderr --version-string=- $< -o $@
 
 .PHONY: verilator.html
 verilator.html:
@@ -214,107 +203,56 @@ verilator.html:
 verilator.pdf: Makefile
 	$(MAKE) -C docs verilator.pdf
 
-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 \
+# 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.
 
 VL_INST_INC_BLDDIR_FILES = \
-  include/verilated_config.h \
-  include/verilated.mk \
+	include/verilated_config.h \
+	include/verilated.mk \
 
 # Files under srcdir, instead of build time
 VL_INST_INC_SRCDIR_FILES = \
-  include/*.[chv]* \
-  include/*.vlt \
-  include/*.sv \
-  include/gtkwave/*.[chv]* \
-  include/vltstd/*.[chv]* \
+	include/*.[chv]* \
+	include/*.sv \
+	include/gtkwave/*.[chv]* \
+	include/vltstd/*.[chv]* \
 
 VL_INST_DATA_SRCDIR_FILES = \
-  examples/*/*.[chv]* \
-  examples/*/CMakeLists.txt \
-  examples/*/Makefile* \
-  examples/*/vl_* \
+	examples/*/*.[chv]* \
+	examples/*/CMakeLists.txt \
+	examples/*/Makefile* \
+	examples/*/vl_* \
 
-mkbindirs:
-	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/bin
+installbin:
 	$(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
+	( 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) )
+	$(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 )
 
 # 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 \
@@ -343,11 +281,8 @@ 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_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)$(bindir) && rm -f $(VL_INST_BIN_FILES)
+	-cd $(DESTDIR)$(pkgdatadir)/bin && rm -f $(VL_INST_BIN_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)
@@ -376,72 +311,59 @@ uninstall:
 	-rmdir $(DESTDIR)$(pkgconfigdir)
 
 install: all_nomsg install-all
-install-all: installbin installredirect installman installdata install-msg
+install-all: installbin installman installdata install-msg
 
 install-here: installman info
 
-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
-
-######################################################################
-# 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)
+# 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 )
+	$(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
+	$(srcdir)/src/*.y \
+	$(srcdir)/src/*.l )
+CPPCHECK = src/cppcheck_filtered cppcheck
+CPPCHECK_FLAGS = --enable=all --inline-suppr \
+	--suppress=cstyleCast --suppress=useInitializationList \
+	--suppress=nullPointer --suppress=nullPointerRedundantCheck --suppress=ctunullpointer \
+	--suppress=unusedFunction --suppress=unusedScopedObject \
+	--suppress=useStlAlgorithm
+CPPCHECK_FLAGS += --xml
+CPPCHECK_DEP = $(subst .cpp,.cppcheck,$(CHECK_CPP))
+CPPCHECK_INC = -I$(srcdir)/include -I$(srcdir)/include/gtkwave -I$(srcdir)/include/vltstd -I$(srcdir)/src/obj_dbg -I$(srcdir)/src
 
-$(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
+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)
 
 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
@@ -460,180 +382,80 @@ analyzer-include:
 	-rm -rf examples/*/obj*
 	scan-build $(MAKE) -k examples
 
-# Bash/sh files
-BASH_FILES = \
-  ci/ci-install.bash \
-  ci/ci-pages-notify.bash \
-  ci/ci-pages.bash \
-  ci/ci-script.bash \
-  ci/docker/run/hooks/post_push \
-  ci/docker/run/verilator-docker \
-  ci/docker/run/verilator-wrap.sh \
-  nodist/fuzzer/all \
-  nodist/fuzzer/run \
-  nodist/fuzzer/setup_root \
-  nodist/fuzzer/setup_user \
+format: clang-format yapf format-pl-exec
 
-# 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* \
-
-# Perl programs
-PERL_PROGRAMS = \
-  bin/redirect \
-  bin/verilator \
-  bin/verilator_coverage \
-
-# 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 \
-  docs/bin/vl_sphinx_extract \
-  docs/bin/vl_sphinx_fix \
-  docs/guide/conf.py \
-  examples/json_py/vl_file_copy \
-  examples/json_py/vl_hier_graph \
-  nodist/clang_check_attributes \
-  nodist/dot_importer \
-  nodist/fuzzer/actual_fail \
-  nodist/fuzzer/generate_dictionary \
-  nodist/install_test \
-  nodist/lint_py_test_filter \
-  nodist/log_changes \
-  nodist/uvm_pkg_packer \
-  nodist/verilator_saif_diff \
-  src/.gdbinit.py \
-  src/astgen \
-  src/bisonpre \
-  src/config_rev \
-  src/flexfix \
-  src/vlcovgen \
-  test_regress/*.py \
-  test_regress/t/*.pf \
-
-# Python files, subject to format but not lint
-PY_FILES = \
-  $(PY_PROGRAMS) \
-  test_regress/t/*.py \
-
-# Python files, test_regress tests
-PY_TEST_FILES = test_regress/t/*.py
-
-# YAML files
-YAML_FILES = \
-  .*.yaml \
-  .*.yml \
-  .github/*.yml \
-  .github/*/*.yml \
-  CITATION.cff \
-
-######################################################################
-# Format
-
-format:
-	$(MAKE) -j 5 format-c format-cmake format-exec format-py format-yaml
-
-BEAUTYSH = beautysh
-BEAUTYSH_FLAGS = --indent-size 2
-
-format-bash:
-	$(BEAUTYSH) --version
-	$(BEAUTYSH) $(BEAUTYSH_FLAGS) $(BASH_FILES)
-
-CLANGFORMAT = clang-format-18
+CLANGFORMAT = clang-format-14
 CLANGFORMAT_FLAGS = -i
 CLANGFORMAT_FILES = $(CHECK_CPP) $(CHECK_H) $(CHECK_YL) test_regress/t/*.c* test_regress/t/*.h
 
-format-c clang-format:
-	$(CLANGFORMAT) --version
-	@$(CLANGFORMAT) --version | fgrep 'version 18' > /dev/null \
-	|| echo "*** You are not using clang-format-18, indents may differ from master's ***"
+clang-format:
+	@$(CLANGFORMAT) --version | egrep 14.0 > /dev/null \
+		|| echo "*** You are not using clang-format-14, indents may differ from master's ***"
 	$(CLANGFORMAT) $(CLANGFORMAT_FLAGS) $(CLANGFORMAT_FILES)
 
-GERSEMI = gersemi
-GERSEMI_FLAGS = -i --no-warn-about-unknown-commands
+PY_PROGRAMS = \
+	bin/verilator_ccache_report \
+	bin/verilator_difftree \
+	bin/verilator_gantt \
+	bin/verilator_includer \
+	bin/verilator_profcfunc \
+	examples/json_py/vl_file_copy \
+	examples/json_py/vl_hier_graph \
+	docs/guide/conf.py \
+	docs/bin/vl_sphinx_extract \
+	docs/bin/vl_sphinx_fix \
+	src/astgen \
+	src/bisonpre \
+	src/config_rev \
+	src/cppcheck_filtered \
+	src/flexfix \
+	src/vlcovgen \
+	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 \
 
-format-cmake:
-	$(GERSEMI) --version
-	$(GERSEMI) $(GERSEMI_FLAGS) $(CMAKE_FILES)
+PY_FILES = \
+	$(PY_PROGRAMS) \
+	nodist/code_coverage.dat \
 
-MBAKE = mbake
-MBAKE_FLAGS = format --config ./.bake.toml
+YAPF = yapf3
+YAPF_FLAGS = -i
 
-format-exec:
-	-chmod a+x test_regress/t/*.py
-
-format-make mbake:
-	$(MBAKE) --version
-	$(MBAKE) $(MBAKE_FLAGS) $(MAKE_FILES)
-
-YAPF = yapf
-YAPF_FLAGS = -i --parallel
-
-format-py yapf:
-	$(YAPF) --version
+yapf:
 	$(YAPF) $(YAPF_FLAGS) $(PY_FILES)
 
-YAMLFIX = YAMLFIX_WHITELINES=1 YAMLFIX_LINE_LENGTH=200 YAMLFIX_preserve_quotes=true yamlfix
-YAMLFIX_FLAGS =
-
-format-yaml yamlfix:
-	$(YAMLFIX) --version
-	$(YAMLFIX) $(YAMLFIX_FLAGS) $(YAML_FILES)
-
-######################################################################
-# Lint
-
-MYPY = mypy
-MYPY_FLAGS = --strict --no-error-summary
-
 PYLINT = pylint
-PYLINT_FLAGS = --recursive=n --score=n --disable=R0801
-PYLINT_TEST_FLAGS = $(PYLINT_FLAGS) --disable=C0103,C0114,C0116,C0209,C0411,C0413,C0301,R0801,R0912,R0915,R0916,R1702,W0511,W0621
+PYLINT_FLAGS = --score=n --disable=R0801
 
 RUFF = ruff
 RUFF_FLAGS = check --ignore=E402,E501,E701
 
 # "make -k" so can see all tool result errors
 lint-py:
-	$(MAKE) -k lint-py-mypy lint-py-mypy-none lint-py-pylint lint-py-pylint-tests lint-py-ruff
-
-lint-py-mypy:
-	for filename in `fgrep -l '# mypy' $(PY_PROGRAMS)`; do \
-		echo "$(MYPY) $(MYPY_FLAGS) $$filename" ; \
-		$(MYPY) $(MYPY_FLAGS) $$filename ; \
-	done
-
-lint-py-mypy-none:
-	@echo "mypy not checking: " `fgrep -L '# mypy' $(PY_PROGRAMS)`
+	$(MAKE) -k lint-py-pylint lint-py-ruff
 
 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)
 
-######################################################################
-# Configure
+format-pl-exec:
+	-chmod a+x test_regress/t/*.pl
+
+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
 
 IN_WILD := ${srcdir}/*.in ${srcdir}/*/*.in
 
@@ -654,152 +476,6 @@ 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."
@@ -807,8 +483,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::
@@ -819,19 +495,28 @@ 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 $(COVERAGE_DIR)
+	rm -rf nodist/obj_dir
 	rm -rf verilator.txt
 
 distclean maintainer-clean::
 	rm -f *.info* *.1 $(INFOS) $(INFOS_OLD) $(VL_INST_MAN_FILES)
-	rm -f Makefile config.status config.cache config.log configure~ TAGS
+	rm -f Makefile config.status config.cache config.log TAGS
 	rm -f verilator_bin* verilator_coverage_bin*
 	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
 
@@ -852,20 +537,3 @@ preexist:
 
 maintainer-dist: preexist tag
 	svnorcvs release $(DISTTAGNAME)
-
-######################################################################
-# Python venv
-
-VENV_PATH ?= .venv
-
-.PHONY: venv
-venv:
-	# Create virtual environment using the python3 picked up by configure
-	[ -e $(VENV_PATH) ] || @PYTHON3@ -m venv --system-site-packages $(VENV_PATH)
-	# Install python3 dependencies
-	$(VENV_PATH)/bin/pip3 install -r python-dev-requirements.txt
-	@echo
-	@echo "Installed Python virtual environment, in:"
-	@echo "  $(VENV_PATH)"
-	@echo "To activate, run:"
-	@echo "  source $(VENV_PATH)/bin/activate"

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
 
-|badge1| |badge2| |badge3| |badge4| |badge5| |badge7| |badge8|
-
-.. |badge1| image:: https://img.shields.io/badge/Website-Verilator.org-181717.svg
-   :target: https://verilator.org
-.. |badge2| image:: https://img.shields.io/badge/License-LGPL%20v3-blue.svg
-   :target: https://www.gnu.org/licenses/lgpl-3.0
-.. |badge3| image:: https://img.shields.io/badge/License-Artistic%202.0-0298c3.svg
-   :target: https://opensource.org/licenses/Artistic-2.0
-.. |badge4| image:: https://repology.org/badge/tiny-repos/verilator.svg?header=distro%20packages
-   :target: https://repology.org/project/verilator/versions
-.. |badge5| image:: https://img.shields.io/docker/pulls/verilator/verilator
-   :target: https://hub.docker.com/r/verilator/verilator
-.. |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
+.. 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
+    :target: https://www.gnu.org/licenses/lgpl-3.0
+.. image:: https://img.shields.io/badge/License-Artistic%202.0-0298c3.svg
+    :target: https://opensource.org/licenses/Artistic-2.0
+.. image:: https://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
+    :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
+    :target: https://github.com/verilator/verilator/actions?query=workflow%3Abuild
 
 
 Welcome to Verilator
@@ -37,7 +37,6 @@ 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**
@@ -54,7 +53,7 @@ Welcome to Verilator
 What Verilator Does
 ===================
 
-Verilator is invoked with parameters similar to GCC or Synopsys's VCS. It
+Verilator is invoked with parameters similar to GCC or Synopsys's VCS.  It
 "Verilates" the specified Verilog or SystemVerilog code by reading it,
 performing lint checks, and optionally inserting assertion checks and
 coverage-analysis points. It outputs single- or multithreaded .cpp and .h
@@ -69,28 +68,29 @@ 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, 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 to
-migrate SystemVerilog to C++/SystemC, or want high-speed simulation of
+`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.
 
 
 Performance
 ===========
 
-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 thread is about 100 times faster than interpreted Verilog simulators
-such as `Icarus Verilog`_. Another 2-10x speedup might be gained from
+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
+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 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.
+Verilator has typically similar or better performance versus
+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.
 
 
 Installation & Documentation
@@ -101,8 +101,8 @@ For more information:
 - `Verilator installation and package directory structure
   <https://verilator.org/install>`_
 
-- `Verilator manual (HTML) <https://verilator.org/verilator_doc.html>`_, or
-  `Verilator manual (PDF) <https://verilator.org/verilator_doc.pdf>`_
+- `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>`_
@@ -132,29 +132,26 @@ organizations; please see `Verilator Commercial Support
 Related Projects
 ================
 
-- `GTKwave <https://gtkwave.sourceforge.net/>`_ - Waveform viewer for
+- `GTKwave <http://gtkwave.sourceforge.net/>`_ - Waveform viewer for
   Verilator traces.
 
-- `Icarus Verilog`_ - Icarus is a highly-featured interpreted Verilog
+- `Icarus Verilog`_ - Icarus is a full-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-2026 by Wilson Snyder. (Report bugs to
+Verilator is Copyright 2003-2024 by Wilson Snyder. (Report bugs to
 `Verilator Issues <https://verilator.org/issues>`_.)
 
 Verilator is free software; you can redistribute it and/or modify it under
 the terms of either the GNU Lesser General Public License Version 3 or the
 Perl Artistic License Version 2.0. See the documentation for more details.
 
-.. _chips alliance: https://chipsalliance.org
-.. _icarus verilog: https://steveicarus.github.io/iverilog
-.. _linux foundation: https://www.linuxfoundation.org
+.. _CHIPS Alliance: https://chipsalliance.org
+.. _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
 .. |verilator usage| image:: https://www.veripool.org/img/verilator_usage_400x200-min.png

bin/redirect

@@ -1,22 +0,0 @@
-#!/usr/bin/env perl
-######################################################################
-#
-# Copyright 2003-2026 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-2026 by Wilson Snyder. This program is free software; you
+# Copyright 2003-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.
@@ -15,7 +15,6 @@ 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);
@@ -28,7 +27,6 @@ autoflush STDOUT 1;
 autoflush STDERR 1;
 
 $Debug = 0;
-my $opt_aslr;
 my $opt_gdb;
 my $opt_rr;
 my $opt_gdbbt;
@@ -42,7 +40,6 @@ if ($#ARGV < 0) {
 }
 
 # Insert debugging options up front
-# (VERILATOR_TEST_FLAGS is not a documented nor official supported feature)
 push @ARGV, (split ' ', $ENV{VERILATOR_TEST_FLAGS} || "");
 
 # We sneak a look at the flags so we can do some pre-environment checks
@@ -58,10 +55,8 @@ 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,
@@ -72,20 +67,6 @@ if (! GetOptions(
     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;
@@ -100,7 +81,7 @@ my @quoted_sw = map { sh_escape($_) } @Opt_Verilator_Sw;
 if ($opt_gdb) {
     # Generic GDB interactive
     run (ulimit_stack_unlimited()
-         . aslr(0)
+         . aslr_off()
          . ($ENV{VERILATOR_GDB} || "gdb")
          . " " . verilator_bin()
          # Note, uncomment to set breakpoints before running:
@@ -117,13 +98,13 @@ if ($opt_gdb) {
 } elsif ($opt_rr) {
     # Record with rr
     run (ulimit_stack_unlimited()
-         . aslr(0)
+         . aslr_off()
          . "rr record " . verilator_bin()
          . " " . join(' ', @quoted_sw));
 } elsif ($opt_gdbbt && $Debug) {
     # Run under GDB to get gdbbt
     run (ulimit_stack_unlimited()
-         . aslr(0)
+         . aslr_off()
          . "gdb"
          . " " . verilator_bin()
          . " --batch --quiet --return-child-result"
@@ -133,24 +114,24 @@ if ($opt_gdb) {
 } 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
+        # Magic number sugested 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)
+         . aslr_off()
          . $valgrind_bin
          . " " . verilator_bin()
          . " " . join(' ', @quoted_sw));
 } elsif ($Debug) {
     # Debug
     run(ulimit_stack_unlimited()
-        . aslr(0)
+        . aslr_off()
         . verilator_bin()
         . " " . join(' ', @quoted_sw));
 } else {
     # Normal, non gdb
-    run(ulimit_stack_unlimited() . aslr(1) . verilator_bin() . " " . join(' ', @quoted_sw));
+    run(ulimit_stack_unlimited() . verilator_bin() . " " . join(' ', @quoted_sw));
 }
 
 #----------------------------------------------------------------------
@@ -170,13 +151,30 @@ 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 (-x "$RealBin/$basename" || -x "$RealBin/$basename.exe") {
-        return "$RealBin/$basename";
+    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
+        }
     } else {
-        return $basename;  # Find in PATH
+        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 $bin;
 }
 
 #######################################################################
@@ -195,37 +193,21 @@ sub gdb_works {
     return $status == 0;
 }
 
-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 ";
-        }
+sub aslr_off {
+    my $ok = `setarch --addr-no-randomize echo ok 2>/dev/null` || "";
+    if ($ok =~ /ok/) {
+        return "setarch --addr-no-randomize ";
+    } else {
+        return "";
     }
-    return "";
 }
 
 sub ulimit_stack_unlimited {
     return "" if !$opt_unlimited_stack;
-    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");
+    system("ulimit -s unlimited 2>/dev/null");
     my $status = $?;
     if ($status == 0) {
-        return "ulimit -s $limit 2>/dev/null; exec ";
+        return "ulimit -s unlimited 2>/dev/null; exec ";
     } else {
         return "";
     }
@@ -246,18 +228,17 @@ sub run {
             warn "%Error: export VERILATOR_ROOT=" . ($ENV{VERILATOR_ROOT} || "") . "\n";
             warn "%Error: $command\n";
         }
-        my $signal = ($status & 127);
-        if ($signal) {
-            if ($signal == 4  # SIGILL
-                || $signal == 8  # SIGFPA
-                || $signal == 11) {  # SIGSEGV
+        if ($status & 127) {
+            if (($status & 127) == 4  # SIGILL
+                || ($status & 127) == 8  # SIGFPA
+                || ($status & 127) == 11) {  # SIGSEGV
                 warn "%Error: Verilator internal fault, sorry. "
                     . "Suggest trying --debug --gdbbt\n" if !$Debug;
-            } elsif ($signal == 6) {  # SIGABRT
+            } elsif (($status & 127) == 6) {  # SIGABRT
                 warn "%Error: Verilator aborted. "
                     . "Suggest trying --debug --gdbbt\n" if !$Debug;
             } else {
-                warn "%Error: Verilator threw signal $signal. "
+                warn "%Error: Verilator threw signal $status. "
                     . "Suggest trying --debug --gdbbt\n" if !$Debug;
             }
         }
@@ -265,8 +246,8 @@ sub run {
             warn "%Error: Command Failed $command\n";
         }
         exit $! if $!;  # errno
-        exit $? >> 8 if $? >> 8;  # pass along child exit code
-        exit 128 + $signal;  # last resort
+        exit $? >> 8 if $? >> 8;  # child exit status
+        exit 255;  # last resort
     }
 }
 
@@ -276,7 +257,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;
 }
 
@@ -289,7 +270,8 @@ __END__
 
 =head1 NAME
 
-Verilator - Lint, compile and simulate SystemVerilog code using C++/SystemC
+Verilator - Translate and simulate SystemVerilog code using C++/SystemC
+
 
 =head1 SYNOPSIS
 
@@ -330,10 +312,8 @@ 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>
-     +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
+    --assert                    Enable all assertions
+    --assert-case               Enable unique/unique0/priority case related checks
     --autoflush                 Flush streams after all $displays
     --bbox-sys                  Blackbox unknown $system calls
     --bbox-unsup                Blackbox unsupported language features
@@ -343,12 +323,11 @@ detailed descriptions of these arguments.
     --build-jobs <jobs>         Parallelism for --build
     --cc                        Create C++ output
      -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
@@ -360,29 +339,23 @@ 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 lower spacing level
     --decorations <level>       Set output comment and spacing level
+    --no-decoration             Disable comments and lower 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-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
+    --dump-<srcfile>            Enable dumping everything in source file
     --dumpi-dfg <level>         Enable dumping DfgGraphs to .dot files at level
     --dumpi-graph <level>       Enable dumping V3Graphs to .dot files at level
     --dumpi-tree <level>        Enable dumping Ast .tree files at level
-    --dumpi-tree-json <level>   Enable dumping Ast .tree.json files at level
+    --dumpi-<srcfile> <level>   Enable dumping everything in source file at level
      -E                         Preprocess, but do not compile
-    --emit-accessors            Emit getter and setter methods for model top class
     --error-limit <value>       Abort after this number of errors
     --exe                       Link to create executable
     --expand-limit <value>      Set expand optimization limit
@@ -398,70 +371,48 @@ detailed descriptions of these arguments.
     --gdb                       Run Verilator under GDB interactively
     --gdbbt                     Run Verilator under GDB for backtrace
     --generate-key              Create random key for --protect-key
-    --get-supported <feature>   Get if feature is supported
     --getenv <var>              Get environment variable with defaults
-    --help                      Show this help
+    --get-supported <feature>   Get if feature is supported
+    --help                      Display 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-cfuncs <value>     Inline CFuncs with <=value nodes (0=off)
-    --inline-cfuncs-product <value>  Inline CFuncs if size*calls <= value
     --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
-     -libmap                    Specify library mapping file
     --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
-    --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
+    --main                      Generate C++ main() file
+    --main-top-name             Specify top name passed to Verilated model in generated C++ main
     --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
-    --output-groups <numfiles>  Group .cpp files into larger ones
+     -o <executable>            Name of final executable
     --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
@@ -472,16 +423,12 @@ detailed descriptions of these arguments.
     --protect-lib <name>        Create a DPI protected library
     --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
+    --public-flat-rw            Mark all variables, etc as public_flat_rw
      -pvalue+<name>=<value>     Overwrite toplevel parameter
-    --quiet                     Minimize additional printing
-    --quiet-build               Don't print build progress
     --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 <value>      Minimum iterations for forming loops
+    --reloop-limit              Minimum iterations for forming loops
     --report-unoptflat          Extra diagnostics for UNOPTFLAT
     --rr                        Run Verilator and record with rr
     --runtime-debug             Enable model runtime debugging
@@ -490,52 +437,46 @@ detailed descriptions of these arguments.
     --no-skip-identical         Disable skipping identical output
     --stats                     Create statistics file
     --stats-vars                Provide statistics on variables
-    --no-std                    Prevent loading standard files
-    --no-std-package            Prevent parsing standard package
-    --no-std-waiver             Prevent parsing standard lint waivers
+    --no-std                    Prevent parsing standard library
     --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-2023ext+<ext>
+     +systemverilogext+<ext>    Synonym for +1800-2017ext+<ext>
     --threads <threads>         Enable multithreading
     --threads-dpi <mode>        Enable multithreaded DPI
     --threads-max-mtasks <mtasks>  Tune maximum mtask partitioning
-    --timescale <timescale>     Sets default timescale
-    --timescale-override <timescale>  Overrides all timescales
     --timing                    Enable timing support
     --no-timing                 Disable timing support
+    --timescale <timescale>     Sets default timescale
+    --timescale-override <timescale>  Overrides all timescales
     --top <topname>             Alias of --top-module
     --top-module <topname>      Name of top-level input module
-    --trace                     Enable VCD waveform creation
+    --trace                     Enable waveform creation
     --trace-coverage            Enable tracing of coverage
     --trace-depth <levels>      Depth of tracing
     --trace-fst                 Enable FST waveform creation
-    --trace-max-array <depth>   Maximum array depth for tracing
-    --trace-max-width <width>   Maximum bit width for tracing
+    --trace-max-array <depth>   Maximum bit width for tracing
+    --trace-max-width <width>   Maximum array depth 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
-    --unroll-limit <loops>      Maximum loop iterations before assuming infinite loop
     --unroll-stmts <stmts>      Tune maximum loop body size
     --unused-regexp <regexp>    Tune UNUSED lint signals
      -V                         Verbose version and config
      -v <filename>              Verilog library
     --valgrind                  Run Verilator under valgrind
-    --no-verilate               Skip Verilation and just compile previously Verilated code
     --verilate-jobs             Job threads for Verilation stage
+    --no-verilate               Skip Verilation and just compile previously Verilated code
      +verilog1995ext+<ext>      Synonym for +1364-1995ext+<ext>
      +verilog2001ext+<ext>      Synonym for +1364-2001ext+<ext>
-    --version                   Show program version and exits
+    --version                   Displays program version and exits
     --vpi                       Enable VPI compiles
-    --waiver-multiline          Create multiline --match for waivers
-    --waiver-output <filename>  Create a waiver file based on linter warnings
+    --waiver-output <filename>  Create a waiver file based on the linter warnings
      -Wall                      Enable all style warnings
      -Werror-<message>          Convert warnings to errors
      -Wfuture-<message>         Disable unknown message warnings
@@ -544,7 +485,6 @@ 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
@@ -552,6 +492,11 @@ detailed descriptions of these arguments.
     --x-assign <mode>           Assign non-initial Xs to this value
     --x-initial <mode>          Assign initial Xs to this value
     --x-initial-edge            Enable initial X->0 and X->1 edge triggers
+    --no-json-edit-nums         Don't dump editNum in .tree.json files
+    --no-json-ids               Don't use short identifiers instead of adresses/paths in .tree.json
+    --json-only                 Create JSON parser output (.tree.json and .meta.json)
+    --json-only-output          .tree.json output filename
+    --json-only-meta-output     .tree.meta.json output filename
     --xml-only                  Create XML parser output
     --xml-output                XML output filename
      -y <dir>                   Directory to search for modules
@@ -563,28 +508,27 @@ 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+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+error+limit+<value>    Set error limit
+     +verilator+help                   Display 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+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
+     +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
 
 
 =head1 DISTRIBUTION
 
 The latest version is available from L<https://verilator.org>.
 
-Copyright 2003-2026 by Wilson Snyder. This program is free software; you can
+Copyright 2003-2024 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,5 +1,4 @@
 #!/usr/bin/env python3
-# mypy: disallow-untyped-defs
 # pylint: disable=C0103,C0114,C0115,C0116,C0123,C0209,C0301,R0902,R0913,R0914,R0912,R0915,W0621
 ######################################################################
 
@@ -17,14 +16,19 @@ parser = argparse.ArgumentParser(
 
     For documentation see
     https://verilator.org/guide/latest/exe_verilator_ccache_report.html""",
-    epilog="""Copyright 2002-2026 by Wilson Snyder. This program is free software; you
+    epilog=
+    """Copyright 2002-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""")
 
-parser.add_argument('-o', type=pathlib.Path, metavar="OUTFILE", required=True, help='output file')
+parser.add_argument('-o',
+                    type=argparse.FileType('w'),
+                    metavar="OUTFILE",
+                    required=True,
+                    help='output file')
 parser.add_argument('logdir', type=pathlib.Path, help='log directory')
 
 args = parser.parse_args()
@@ -33,7 +37,7 @@ results = {}
 elapsed = {}
 
 
-def toDateTime(s: str) -> datetime:
+def toDateTime(s):
     return datetime.strptime(s, "%Y-%m-%dT%H:%M:%S.%f")
 
 
@@ -50,39 +54,44 @@ 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)
 
-with args.o.open("w") as ofd:
-    ofd.write("#" * 80 + "\n")
-    ofd.write("ccache report (from verilator_ccache_report) :\n")
+args.o.write("#" * 80 + "\n")
+args.o.write("ccache report (from verilator_ccache_report) :\n")
 
-    if not results:
-        ofd.write("\nAll object files up to date\n")
-    else:
-        ofd.write("\nCompiled object files:\n")
-        wnames = max(len(_) for _ in results) + 1
-        wresults = max(len(_) for _ in results.values()) + 1
-        for k in sorted(results.keys()):
-            ofd.write("{:{wnames}} : {:{wresults}} : {}s\n".format(k,
-                                                                   results[k],
-                                                                   elapsed[k].total_seconds(),
-                                                                   wnames=wnames,
-                                                                   wresults=wresults))
+if not results:
+    args.o.write("\nAll object files up to date\n")
+else:
+    args.o.write("\nCompiled object files:\n")
+    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))
 
-        ofd.write("\nSummary:\n")
-        counts = collections.Counter(_ for _ in results.values())
-        total = sum(counts.values())
-        for k in sorted(counts.keys()):
-            c = counts[k]
-            ofd.write("{:{width}}| {} ({:.2%})\n".format(k, c, c / total, width=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))
 
-        ofd.write("\nLongest:\n")
-        longest = sorted(list(elapsed.items()), key=lambda kv: -kv[1].total_seconds())
-        for i, (k, v) in enumerate(longest):
-            ofd.write("{:{width}}| {}s\n".format(k, v.total_seconds(), width=wnames))
-            if i > 4:
-                break
+    args.o.write("\nLongest:\n")
+    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))
+        if i > 4:
+            break
 
-    ofd.write("#" * 80 + "\n")
+args.o.write("#" * 80 + "\n")

bin/verilator_coverage

@@ -1,7 +1,7 @@
 #!/usr/bin/env perl
 ######################################################################
 #
-# Copyright 2003-2026 by Wilson Snyder. This program is free software; you
+# Copyright 2003-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.
@@ -118,24 +118,21 @@ sub run {
             warn "%Error: export VERILATOR_ROOT=" . ($ENV{VERILATOR_ROOT} || "") . "\n";
             warn "%Error: $command\n";
         }
-        my $signal = ($status & 127);
-        if ($signal) {
-            if ($signal == 4  # SIGILL
-                || $signal == 8  # SIGFPA
-                || $signal == 11) {  # SIGSEGV
+        if ($status & 127) {
+            if (($status & 127) == 8 || ($status & 127) == 11) {  # SIGFPA or SIGSEGV
                 warn "%Error: Verilator_coverage internal fault, sorry.\n" if !$Debug;
-            } elsif ($signal == 6) {  # SIGABRT
+            } elsif (($status & 127) == 6) {  # SIGABRT
                 warn "%Error: Verilator_coverage aborted.\n" if !$Debug;
             } else {
-                warn "%Error: Verilator_coverage threw signal $signal.\n" if !$Debug;
+                warn "%Error: Verilator_coverage threw signal $status.\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;  # pass along child exit code
-        exit 128 + $signal;  # last resort
+        exit $? >> 8 if $? >> 8;  # child exit status
+        exit 255;  # last resort
     }
 }
 
@@ -157,9 +154,9 @@ verilator_coverage - Verilator coverage analyzer
 
     verilator_coverage --annotate <obj>
 
-    verilator_coverage  -write merged.dat <datafiles>...
+    verilator_coverage  -write merged.dat -read <datafiles>...
 
-    verilator_coverage  -write-info merged.info <datafiles>...
+    verilator_coverage  -write-info merged.info -read <datafiles>...
 
 Verilator_coverage processes Verilated model-generated coverage reports.
 
@@ -173,7 +170,6 @@ 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
@@ -192,7 +188,7 @@ L<https://verilator.org/guide/latest/exe_verilator_coverage.html>.
 
 The latest version is available from L<https://verilator.org>.
 
-Copyright 2003-2026 by Wilson Snyder. This program is free software; you
+Copyright 2003-2024 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,6 +1,5 @@
 #!/usr/bin/env python3
-# mypy: disallow-untyped-defs
-# pylint: disable=C0103,C0114,C0116,C0209,W0603
+# pylint: disable=C0103,C0114,C0116,C0209
 ######################################################################
 
 import argparse
@@ -10,29 +9,25 @@ 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.stderr.write("%Error: No old diff filename found: " + a + "\n")
-        sys.exit(2)
+        sys.exit("%Error: No old diff filename found: " + a)
     if not os.path.exists(b):
-        sys.stderr.write("%Error: No new diff filename found: " + b + "\n")
-        sys.exit(2)
+        sys.exit("%Error: No new diff filename found: " + b)
 
     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.stderr.write("%Error: Mix of files and dirs")
-        sys.exit(2)
+        sys.exit("%Error: Mix of files and dirs")
 
 
-def diff_dir(a: str, b: str) -> None:
+def diff_dir(a, b):
     # Diff all files under two directories
-    files: dict[str, dict[str, str]] = collections.defaultdict(lambda: {})
+    files = collections.defaultdict(lambda: {})
 
     for fn in glob.glob(a + "/*.tree"):
         base = re.sub(r'.*/', '', fn)
@@ -52,12 +47,11 @@ def diff_dir(a: str, b: str) -> None:
         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: str, b: str) -> None:
-    global exit_code
-
+def diff_file(a, b):
     # 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)
@@ -72,18 +66,25 @@ def diff_file(a: str, b: str) -> None:
 
     filterf(a, tmp_a)
     filterf(b, tmp_b)
-    status = os.system("diff -u " + tmp_a + " " + tmp_b)
+    os.system("diff -u " + tmp_a + " " + tmp_b)
     os.unlink(tmp_a)
     os.unlink(tmp_b)
 
-    status_exit_code = status >> 8
-    if status_exit_code == 1:
-        exit_code = 1
-    elif status_exit_code:
-        exit_code = 2
+
+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
 
 
-def filterf(fn1: str, fn2: str) -> None:
+def filterf(fn1, fn2):
     # Remove hex numbers before diffing
     with open(fn1, "r", encoding="utf8") as fh1:
         with open(fn2, "w", encoding="utf8") as fh2:
@@ -107,17 +108,19 @@ 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.
-
-Exit status is 0 if inputs are the same, 1 if different, 2 if trouble.""",
-    epilog="""Copyright 2005-2026 by Wilson Snyder. This program is free software; you
+directories, ignoring irrelevant pointer differences.""",
+    epilog=
+    """Copyright 2005-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""")
 
-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')
@@ -126,7 +129,6 @@ 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

@@ -8,10 +8,9 @@ import collections
 import math
 import re
 import statistics
-from collections import OrderedDict
 # from pprint import pprint
 
-Sections = OrderedDict()
+Sections = []
 LongestVcdStrValueLength = 0
 Threads = collections.defaultdict(lambda: [])  # List of records per thread id
 Mtasks = collections.defaultdict(lambda: {'elapsed': 0, 'end': 0})
@@ -19,48 +18,37 @@ Cpus = collections.defaultdict(lambda: {'mtask_time': 0})
 Global = {
     'args': {},
     'cpuinfo': collections.defaultdict(lambda: {}),
-    '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
+ExecGraphTime = 0  # total elapsed time excuting an exec graph
 ExecGraphIntervals = []  # list of (start, end) pairs
-ThreadScheduleWaitIntervals = []  # list of (start, tick, ecpu) pairs
 
 ######################################################################
 
 
-def read_data(filename: str) -> None:
+def read_data(filename):
     with open(filename, "r", encoding="utf8") as fh:
         re_thread = re.compile(r'^VLPROFTHREAD (\d+)$')
         re_record = re.compile(r'^VLPROFEXEC (\S+) (\d+)(.*)$')
-        # The hierBlock argument is optional
         re_payload_mtaskBegin = re.compile(
-            r'id (\d+) predictStart (\d+) cpu (\d+)(?: hierBlock)?\s*(\w+)?')
-        re_payload_mtaskEnd = re.compile(r'predictCost (\d+)')
-        re_payload_wait = re.compile(r'cpu (\d+)')
+            r'id (\d+) predictStart (\d+) cpu (\d+)')
+        re_payload_mtaskEnd = re.compile(r'id (\d+) predictCost (\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_info = re.compile(r'VLPROF info\s+(\S+)\s+(.*)$')
-        re_stat = re.compile(r'VLPROF stat\s+(\S+)\s+(\S+)')
+        re_stat = re.compile(r'VLPROF stat\s+(\S+)\s+([0-9.]+)')
         re_proc_cpu = re.compile(r'VLPROFPROC processor\s*:\s*(\d+)\s*$')
         re_proc_dat = re.compile(r'VLPROFPROC ([a-z_ ]+)\s*:\s*(.*)$')
         cpu = None
-        thread = 0
-        thread_last_ecpu = None
+        thread = None
+        execGraphStart = None
 
         global LongestVcdStrValueLength
         global ExecGraphTime
-        global WaitingTime
 
-        ExecGraphStack = []
         SectionStack = []
-        MtasksStack = []
-        ThreadScheduleWait = collections.defaultdict(list)
+        mTaskThread = {}
 
         for line in fh:
             recordMatch = re_record.match(line)
@@ -69,69 +57,55 @@ def read_data(filename: str) -> None:
                 tick = int(tick)
                 payload = payload.strip()
                 if kind == "SECTION_PUSH":
-                    LongestVcdStrValueLength = max(LongestVcdStrValueLength, len(payload))
+                    LongestVcdStrValueLength = max(LongestVcdStrValueLength,
+                                                   len(payload))
                     SectionStack.append(payload)
-                    Sections[thread].append((tick, tuple(SectionStack)))
+                    Sections.append((tick, tuple(SectionStack)))
                 elif kind == "SECTION_POP":
                     assert SectionStack, "SECTION_POP without SECTION_PUSH"
                     SectionStack.pop()
-                    Sections[thread].append((tick, tuple(SectionStack)))
+                    Sections.append((tick, tuple(SectionStack)))
                 elif kind == "MTASK_BEGIN":
-                    mtask, predict_start, ecpu, hier_block = re_payload_mtaskBegin.match(
+                    mtask, predict_start, ecpu = re_payload_mtaskBegin.match(
                         payload).groups()
-                    hier_block = "" if hier_block is None else hier_block
                     mtask = int(mtask)
                     predict_start = int(predict_start)
                     ecpu = int(ecpu)
+                    mTaskThread[mtask] = thread
                     records = Threads[thread]
+                    assert not records or records[-1]['start'] <= records[-1][
+                        'end'] <= tick
                     records.append({
                         'start': tick,
                         'mtask': mtask,
                         'predict_start': predict_start,
-                        'hier_block': hier_block,
                         'cpu': ecpu
                     })
-                    Mtasks[(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]))
+                    Mtasks[mtask]['begin'] = tick
+                    Mtasks[mtask]['thread'] = thread
+                    Mtasks[mtask]['predict_start'] = predict_start
                 elif kind == "MTASK_END":
-                    predict_cost, = re_payload_mtaskEnd.match(payload).groups()
+                    mtask, predict_cost = re_payload_mtaskEnd.match(
+                        payload).groups()
                     mtask = int(mtask)
-                    hier_block, mtask, record = MtasksStack.pop()
                     predict_cost = int(predict_cost)
-                    begin = Mtasks[(hier_block, mtask)]['begin']
+                    begin = Mtasks[mtask]['begin']
+                    record = Threads[mTaskThread[mtask]][-1]
                     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))
+                    Mtasks[mtask]['elapsed'] += tick - begin
+                    Mtasks[mtask]['predict_cost'] = predict_cost
+                    Mtasks[mtask]['end'] = max(Mtasks[mtask]['end'], tick)
                 elif kind == "EXEC_GRAPH_BEGIN":
-                    ExecGraphStack.append(tick)
+                    execGraphStart = tick
                 elif kind == "EXEC_GRAPH_END":
-                    assert ExecGraphStack, "EXEC_GRAPH_END without EXEC_GRAPH_BEGIN"
-                    execGraphStart = ExecGraphStack.pop()
                     ExecGraphTime += tick - execGraphStart
                     ExecGraphIntervals.append((execGraphStart, tick))
+                    execGraphStart = None
                 elif Args.debug:
                     print("-Unknown execution trace record: %s" % line)
             elif re_thread.match(line):
                 thread = int(re_thread.match(line).group(1))
-                Sections[thread] = []
             elif re.match(r'^VLPROF(THREAD|VERSION)', line):
                 pass
             elif re_arg1.match(line):
@@ -140,9 +114,6 @@ def read_data(filename: str) -> None:
             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)
@@ -171,7 +142,7 @@ def re_match_result(regexp, line, result_to):
 ######################################################################
 
 
-def report() -> None:
+def report():
     print("Verilator Gantt report")
 
     print("\nArgument settings:")
@@ -192,26 +163,28 @@ def report() -> None:
 
     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("  Parallelized code  = {:.2%} of elapsed time".format(
+        ExecGraphTime / 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("%%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(
+                "%Warning: Multiple threads scheduled on same hyperthreaded core."
+            )
             print("        : See docs on use of numactl.")
         if 'cpu_sockets_warning' in Global:
             print()
@@ -220,12 +193,7 @@ def report() -> None:
     print()
 
 
-def report_numa() -> None:
-    print("\nNUMA assignment:")
-    print("  NUMA status        = %s" % Global['info']['numa'])
-
-
-def report_mtasks() -> None:
+def report_mtasks():
     if not Mtasks:
         return
 
@@ -243,11 +211,10 @@ def report_mtasks() -> None:
     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)]
+    for mtaskId in Mtasks:
+        record = Mtasks[mtaskId]
         predict_mtask_time += record['predict_cost']
         total_mtask_time += record['elapsed']
         thread_mtask_time[record['thread']] += record['elapsed']
@@ -255,14 +222,14 @@ def report_mtasks() -> None:
         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
+            long_mtask = mtaskId
     Global['predict_last_end'] = predict_elapsed
 
     serialTime = ElapsedTime - ExecGraphTime
 
     def subReport(elapsed, work):
-        print("  Thread utilization = {:7.2%}".format(work / (elapsed * nthreads)))
+        print("  Thread utilization = {:7.2%}".format(work /
+                                                      (elapsed * nthreads)))
         print("  Speedup            = {:6.3}x".format(work / elapsed))
 
     print("\nParallelized code, measured:")
@@ -285,55 +252,36 @@ def report_mtasks() -> None:
     max_p2e = -1000000
     max_mtask = None
 
-    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'])
+    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)
 
             if p2e_ratio > max_p2e:
                 max_p2e = p2e_ratio
-                max_mtask = mtask_id
-                max_hier_block = hier_block
+                max_mtask = mtask
             if p2e_ratio < min_p2e:
                 min_p2e = p2e_ratio
-                min_mtask = mtask_id
-                min_hier_block = hier_block
+                min_mtask = mtask
 
     print("\nMTask statistics:")
-    if long_mtask_hier_block:
-        print("  Longest mtask id = {} from hier_block '{}'".format(long_mtask,
-                                                                    long_mtask_hier_block))
-    else:
-        print("  Longest mtask id = {}".format(long_mtask))
-    print("  Longest mtask time = {:.2%} of time elapsed in parallelized code".format(
-        long_mtask_time / ExecGraphTime))
+    print("  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("  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="")
-    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'])
+    print("  from mtask %d (predict %d," %
+          (max_mtask, Mtasks[max_mtask]['predict_cost']),
+          end="")
+    print(" elapsed %d)" % Mtasks[max_mtask]['elapsed'])
 
     stddev = statistics.pstdev(p2e_ratios)
     mean = statistics.mean(p2e_ratios)
@@ -342,7 +290,7 @@ def report_mtasks() -> None:
     print("  e ^ stddev = %0.3f" % math.exp(stddev))
 
 
-def report_cpus() -> None:
+def report_cpus():
     print("\nCPU info:")
 
     Global['cpu_sockets'] = collections.defaultdict(lambda: 0)
@@ -367,8 +315,8 @@ def report_cpus() -> None:
                 model = cpuinfo['model_name']
 
         print("  {:3d} | {:7.2%} / {:16d} | {:>6s} | {:>4s} | {}".format(
-            cpu, Cpus[cpu]['mtask_time'] / ElapsedTime, Cpus[cpu]['mtask_time'], socket, core,
-            model))
+            cpu, Cpus[cpu]['mtask_time'] / ElapsedTime,
+            Cpus[cpu]['mtask_time'], socket, core, model))
 
     if len(Global['cpu_sockets']) > 1:
         Global['cpu_sockets_warning'] = True
@@ -377,28 +325,24 @@ def report_cpus() -> None:
                 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_sections():
+    if not Sections:
+        return
+    print("\nSection profile:")
 
-
-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:
+    for time, stack in Sections:
         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])
@@ -422,8 +366,8 @@ def report_section(section) -> None:
 
     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))
+            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])
 
@@ -436,7 +380,7 @@ def report_section(section) -> None:
 ######################################################################
 
 
-def write_vcd(filename: str) -> None:
+def write_vcd(filename):
     print("Writing %s" % filename)
     with open(filename, "w", encoding="utf8") as fh:
         # dict of dicts of hierarchy elements/signal name  -> (code, width)
@@ -473,9 +417,6 @@ def write_vcd(filename: str) -> None:
                 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)
@@ -497,39 +438,33 @@ def write_vcd(filename: str) -> None:
                 addValue(code, start, mtask)
                 addValue(code, end, None)
 
-        tStart = sorted(_['start'] for records in Threads.values() for _ in records)
-        tEnd = sorted(_['end'] for records in Threads.values() for _ in records)
-
-        # Measured waiting time
-        for (start, end, cpu) in ThreadScheduleWaitIntervals:
-            mcode = getCode(32, 'measured', 'cpu%d_waiting' % cpu)
-            addXValue(mcode, start)
-            addValue(mcode, end, None)
+        tStart = sorted(_['start'] for records in Threads.values()
+                        for _ in records)
+        tEnd = sorted(_['end'] for records in Threads.values()
+                      for _ in records)
 
         # 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]
+            start = tStart[bisect.bisect_left(tStart, start)]
             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)
+            for mtask in Mtasks:
+                thread = Mtasks[mtask]['thread']
+                pred_scaled_start = start + int(
+                    Mtasks[mtask]['predict_start'] * measured_scaling)
                 pred_scaled_end = start + int(
-                    (mtask['predict_start'] + mtask['predict_cost']) * measured_scaling)
+                    (Mtasks[mtask]['predict_start'] +
+                     Mtasks[mtask]['predict_cost']) * measured_scaling)
                 if pred_scaled_start == pred_scaled_end:
                     continue
 
                 mcode = getCode(32, 'predicted', 't%d_mtask' % thread)
-                addValue(mcode, pred_scaled_start, mtask_id)
+                addValue(mcode, pred_scaled_start, mtask)
                 addValue(mcode, pred_scaled_end, None)
 
                 parallelism['predicted'][pred_scaled_start] += 1
@@ -544,13 +479,12 @@ def write_vcd(filename: str) -> None:
                 addValue(pcode, time, 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))
+        if Sections:
+            scode = getCode(LongestVcdStrValueLength * 8, "section", "trace")
+            dcode = getCode(32, "section", "depth")
+            for time, stack in Sections:
+                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")
@@ -592,8 +526,6 @@ def write_vcd(filename: str) -> None:
                 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:
@@ -605,7 +537,7 @@ def write_vcd(filename: str) -> None:
 parser = argparse.ArgumentParser(
     allow_abbrev=False,
     formatter_class=argparse.RawDescriptionHelpFormatter,
-    description="""Create Gantt chart of Verilator multi-threaded execution
+    description="""Create Gantt chart of multi-threaded execution.
 
 Verilator_gantt creates a visual representation to help analyze Verilator
 #xmultithreaded simulation performance, by showing when each macro-task
@@ -613,7 +545,8 @@ 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-2026 by Wilson Snyder. This program is free software; you
+    epilog=
+    """Copyright 2018-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.
@@ -621,8 +554,12 @@ 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 output', default='profile_exec.vcd')
+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('filename',
                     help='input profile_exec.dat filename to process',
                     default='profile_exec.dat')

bin/verilator_includer

@@ -1,8 +1,7 @@
 #!/usr/bin/env python3
-# mypy: disallow-untyped-defs
 # pylint: disable=C0114,C0209
 #
-# Copyright 2003-2026 by Wilson Snyder. This program is free software; you
+# Copyright 2003-2024 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: str) -> None:
+def profcfunc(filename):
     funcs = {}
 
     with open(filename, "r", encoding="utf8") as fh:
@@ -26,7 +26,7 @@ def profcfunc(filename: str) -> None:
                 calls = float(match.group(3))
                 func = match.group(4)
                 if func not in funcs:
-                    funcs[func] = {'pct': 0.0, 'sec': 0.0, 'calls': 0}
+                    funcs[func] = {'pct': 0, 'sec': 0, 'calls': 0}
                 funcs[func]['pct'] += pct
                 funcs[func]['sec'] += sec
                 funcs[func]['calls'] += calls
@@ -34,8 +34,9 @@ def profcfunc(filename: str) -> None:
 
             # 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))
@@ -135,27 +136,33 @@ def profcfunc(filename: str) -> None:
 
     design_width = 1
     for func, func_item in vfuncs.items():
-        design_width = max(design_width, len(func_item['design']))
+        if design_width < len(func_item['design']):
+            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.0
-    for func in sorted(vfuncs.keys(), key=lambda f: vfuncs[f]['sec'], reverse=True):
+    cume = 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))
 
 
 ######################################################################
@@ -164,7 +171,7 @@ def profcfunc(filename: str) -> None:
 parser = argparse.ArgumentParser(
     allow_abbrev=False,
     formatter_class=argparse.RawDescriptionHelpFormatter,
-    description="""Read gprof report created with Verilator --prof-cfuncs
+    description="""Read gprof report created with --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
@@ -173,14 +180,18 @@ in each Verilog block.
 
 For documentation see
 https://verilator.org/guide/latest/exe_verilator_profcfunc.html""",
-    epilog="""Copyright 2002-2026 by Wilson Snyder. This program is free software; you
+    epilog=
+    """Copyright 2002-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""")
 
-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

@@ -0,0 +1,30 @@
+#!/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
+# 22.04: ccache -s -v -z
+ccache -s -z

ci/ci-install.bash

@@ -37,17 +37,10 @@ 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 dca845020668887fd13498c772939814d9264fd5
+  git -C "${TMP_DIR}" checkout e5664be5fe39d353bf3fcb50aa05214ab7ed4ac4
   "$MAKE" -C "${TMP_DIR}"
   sudo cp "${TMP_DIR}/vcddiff" /usr/local/bin
 }
@@ -62,22 +55,25 @@ 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-22.04" ]]; then
+    if [ "$CI_RUNS_ON" = "ubuntu-20.04" ]; then
       # Some conflict of libunwind verison on 22.04, can live without it for now
       sudo apt-get install libgoogle-perftools-dev ||
       sudo apt-get install libgoogle-perftools-dev
     fi
-    if [[ "$CI_RUNS_ON" =~ "ubuntu-20.04" ]] || [[ "$CI_RUNS_ON" =~ "ubuntu-22.04" ]] || [[ "$CI_RUNS_ON" =~ "ubuntu-24.04" ]]; then
+    if [ "$CI_RUNS_ON" = "ubuntu-20.04" ] || [ "$CI_RUNS_ON" = "ubuntu-22.04" ]; then
       sudo apt-get install libsystemc libsystemc-dev ||
       sudo apt-get install libsystemc libsystemc-dev
     fi
-    if [[ "$CI_RUNS_ON" =~ "ubuntu-22.04" ]] || [[ "$CI_RUNS_ON" =~ "ubuntu-24.04" ]]; then
+    if [ "$CI_RUNS_ON" = "ubuntu-22.04" ]; then
       sudo apt-get install bear mold ||
       sudo apt-get install bear mold
     fi
+    if [ "$COVERAGE" = 1 ]; then
+      yes yes | sudo cpan -fi Parallel::Forker
+    fi
   elif [ "$CI_OS_NAME" = "osx" ]; then
     brew update
-    brew install ccache perl gperftools autoconf bison flex help2man
+    brew install ccache perl gperftools
   elif [ "$CI_OS_NAME" = "freebsd" ]; then
     sudo pkg install -y autoconf bison ccache gmake perl5
   else
@@ -85,7 +81,7 @@ if [ "$CI_BUILD_STAGE_NAME" = "build" ]; then
   fi
 
   if [ -n "$CCACHE_DIR" ]; then
-    mkdir -p "$CCACHE_DIR"
+    mkdir -p "$CCACHE_DIR" && ./ci/ci-ccache-maint.bash
   fi
 elif [ "$CI_BUILD_STAGE_NAME" = "test" ]; then
   ##############################################################################
@@ -96,31 +92,34 @@ 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 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
+    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
     fi
-    if [[ "$CI_RUNS_ON" =~ "ubuntu-20.04" ]] || [[ "$CI_RUNS_ON" =~ "ubuntu-22.04" ]] || [[ "$CI_RUNS_ON" =~ "ubuntu-24.04" ]]; then
+    if [ "$CI_RUNS_ON" = "ubuntu-20.04" ] || [ "$CI_RUNS_ON" = "ubuntu-22.04" ]; then
       sudo apt-get install libsystemc-dev ||
       sudo apt-get install libsystemc-dev
     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 jq z3
+    brew install ccache perl
   elif [ "$CI_OS_NAME" = "freebsd" ]; then
     # fst2vcd fails with "Could not open '<input file>', exiting."
-    sudo pkg install -y ccache gmake perl5 python3 jq z3
+    sudo pkg install -y ccache gmake perl5 python3
   else
     fatal "Unknown os: '$CI_OS_NAME'"
   fi
   # Common installs
+  if [ "$CI_RUNS_ON" != "ubuntu-14.04" ]; then
+    CI_CPAN_REPO=https://cpan.org
+  fi
+  yes yes | sudo cpan -M $CI_CPAN_REPO -fi Parallel::Forker
   install-vcddiff
-  # Workaround -fsanitize=address crash
-  sudo sysctl -w vm.mmap_rnd_bits=28
 else
   ##############################################################################
   # Unknown build stage

ci/ci-pages-notify.bash

@@ -1,46 +0,0 @@
-#!/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

@@ -1,171 +0,0 @@
-#!/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

@@ -27,48 +27,40 @@ if [ "$CI_OS_NAME" = "linux" ]; then
 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
 
-  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
+  if [ "$COVERAGE" != 1 ]; then
+    autoconf
+    ./configure --enable-longtests --enable-ccwarn
+    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
+  else
+    nodist/code_coverage --stages 0-2
   fi
 elif [ "$CI_BUILD_STAGE_NAME" = "test" ]; then
   ##############################################################################
   # Run tests
 
   export VERILATOR_TEST_NO_CONTRIBUTORS=1  # Separate workflow check
-  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
@@ -92,119 +84,104 @@ elif [ "$CI_BUILD_STAGE_NAME" = "test" ]; then
     export VERILATOR_TEST_NO_GPROF=1 # gprof is a bit different on FreeBSD, disable
   fi
 
-  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 sanitize on Ubuntu 22.04 only
+  [ "$CI_RUNS_ON" = 'ubuntu-22.04' ] && sanitize='--sanitize' || sanitize=''
 
   # Run the specified test
   ccache -z
   case $TESTS in
     dist-vlt-0)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--dist --vlt --driver-clean" DRIVER_HASHSET=--hashset=0/4
+      "$MAKE" -C test_regress SCENARIOS="--dist --vlt $sanitize" DRIVER_HASHSET=--hashset=0/3
       ;;
     dist-vlt-1)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--dist --vlt --driver-clean" DRIVER_HASHSET=--hashset=1/4
+      "$MAKE" -C test_regress SCENARIOS="--dist --vlt $sanitize" DRIVER_HASHSET=--hashset=1/3
       ;;
     dist-vlt-2)
-      "$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
+      "$MAKE" -C test_regress SCENARIOS="--dist --vlt $sanitize" DRIVER_HASHSET=--hashset=2/3
       ;;
     vltmt-0)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt --driver-clean" DRIVER_HASHSET=--hashset=0/3
+      "$MAKE" -C test_regress SCENARIOS=--vltmt DRIVER_HASHSET=--hashset=0/2
       ;;
     vltmt-1)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt --driver-clean" DRIVER_HASHSET=--hashset=1/3
+      "$MAKE" -C test_regress SCENARIOS=--vltmt DRIVER_HASHSET=--hashset=1/2
       ;;
-    vltmt-2)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt --driver-clean" DRIVER_HASHSET=--hashset=2/3
+    coverage-all)
+      nodist/code_coverage --stages 1-
       ;;
     coverage-dist)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--dist"
+      nodist/code_coverage --stages 1- --scenarios=--dist
       ;;
     coverage-vlt-0)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vlt" DRIVER_HASHSET=--hashset=0/10
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=0/10
       ;;
     coverage-vlt-1)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vlt" DRIVER_HASHSET=--hashset=1/10
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=1/10
       ;;
     coverage-vlt-2)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vlt" DRIVER_HASHSET=--hashset=2/10
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=2/10
       ;;
     coverage-vlt-3)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vlt" DRIVER_HASHSET=--hashset=3/10
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=3/10
       ;;
     coverage-vlt-4)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vlt" DRIVER_HASHSET=--hashset=4/10
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=4/10
       ;;
     coverage-vlt-5)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vlt" DRIVER_HASHSET=--hashset=5/10
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=5/10
       ;;
     coverage-vlt-6)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vlt" DRIVER_HASHSET=--hashset=6/10
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=6/10
       ;;
     coverage-vlt-7)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vlt" DRIVER_HASHSET=--hashset=7/10
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=7/10
       ;;
     coverage-vlt-8)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vlt" DRIVER_HASHSET=--hashset=8/10
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=8/10
       ;;
     coverage-vlt-9)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vlt" DRIVER_HASHSET=--hashset=9/10
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=9/10
       ;;
     coverage-vltmt-0)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt" DRIVER_HASHSET=--hashset=0/10
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=0/10
       ;;
     coverage-vltmt-1)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt" DRIVER_HASHSET=--hashset=1/10
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=1/10
       ;;
     coverage-vltmt-2)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt" DRIVER_HASHSET=--hashset=2/10
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=2/10
       ;;
     coverage-vltmt-3)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt" DRIVER_HASHSET=--hashset=3/10
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=3/10
       ;;
     coverage-vltmt-4)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt" DRIVER_HASHSET=--hashset=4/10
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=4/10
       ;;
     coverage-vltmt-5)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt" DRIVER_HASHSET=--hashset=5/10
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=5/10
       ;;
     coverage-vltmt-6)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt" DRIVER_HASHSET=--hashset=6/10
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=6/10
       ;;
     coverage-vltmt-7)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt" DRIVER_HASHSET=--hashset=7/10
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=7/10
       ;;
     coverage-vltmt-8)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt" DRIVER_HASHSET=--hashset=8/10
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=8/10
       ;;
     coverage-vltmt-9)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt" DRIVER_HASHSET=--hashset=9/10
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --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,26 +1,13 @@
-# 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,16 +1,3 @@
-# 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
@@ -18,9 +5,6 @@ mkdir build
 cd build
 cmake ..
 cmake --build . --config Release -j 3
-
-# TODO put this back in, see issue# 5163
-# Release/example.exe
-
+Release/example.exe
 cd ..
 Remove-Item -path build -recurse

ci/docker/buildenv/Dockerfile

@@ -6,7 +6,7 @@
 # Version 2.0.
 # SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 
-FROM ubuntu:24.04
+FROM ubuntu:22.04
 
 # Create the user
 RUN groupadd verilator \
@@ -36,16 +36,13 @@ RUN apt-get update \
                         help2man \
                         libfl2 \
                         libfl-dev \
-                        libclang-rt-18-dev \
                         libgoogle-perftools-dev \
                         libsystemc \
                         libsystemc-dev \
                         numactl \
                         perl \
                         python3 \
-                        python3-distro \
                         wget \
-                        z3 \
                         zlib1g \
                         zlib1g-dev \
     && apt-get clean \
@@ -53,6 +50,8 @@ 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 && \

ci/docker/buildenv/README.rst

@@ -1,19 +1,17 @@
-.. Copyright 2003-2026 by Wilson Snyder.
+.. Copyright 2003-2024 by Wilson Snyder.
 .. SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 
-.. _verilator build docker container:
-
 Verilator Build Docker Container
 ================================
 
 This Verilator Build Docker Container is set up to compile and test a
 Verilator build. It uses the following parameters:
 
-- Source repository (default: https://github.com/verilator/verilator)
+-  Source repository (default: https://github.com/verilator/verilator)
 
-- Source revision (default: master)
+-  Source revision (default: master)
 
-- Compiler (GCC 13.3.0, clang 18.1.3, default: 13.3.0)
+-  Compiler (GCC 10.3.0, clang 10.0.0, default: 10.3.0)
 
 The container is published as ``verilator/verilator-buildenv`` on `docker
 hub
@@ -31,19 +29,18 @@ To also run tests:
 
    docker run -ti verilator/verilator-buildenv test
 
-To change the compiler use the `-e` switch to pass environment variables:
+To change the compiler:
 
 ::
 
-   docker run -ti -e CXX=clang++-18 verilator/verilator-buildenv test
+   docker run -ti -e CC=clang-10 -e CXX=clang++-10 verilator/verilator-buildenv test
 
-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:
+The tests that involve gdb are not working due to security restrictions.
+To run those too:
 
 ::
 
-   docker run -ti --cap-add=CAP_SYS_NICE verilator/verilator-buildenv test
+   docker run -ti -e CC=clang-10 -e CXX=clang++-10 --cap-add=SYS_PTRACE --security-opt seccomp=unconfined verilator/verilator-buildenv test
 
 Rather then building using a remote git repository you may prefer to use a
 working copy on the local filesystem. Mount the local working copy path as
@@ -53,7 +50,7 @@ top of a repository:
 
 ::
 
-   docker run -ti -v ${PWD}:/tmp/repo -e REPO=/tmp/repo -e REV=`git rev-parse --short HEAD` verilator/verilator-buildenv test
+   docker run -ti -v ${PWD}:/tmp/repo -e REPO=/tmp/repo -e REV=`git rev-parse --short HEAD` --cap-add=SYS_PTRACE --security-opt seccomp=unconfined verilator/verilator-buildenv test
 
 
 Rebuilding

ci/docker/buildenv/build.sh

@@ -9,6 +9,7 @@
 
 : "${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:24.04
+FROM ubuntu:22.04
 
 RUN apt-get update \
     && DEBIAN_FRONTEND=noninteractive \
@@ -48,8 +48,7 @@ RUN git clone "${REPO}" verilator && \
     make && \
     make install && \
     cd .. && \
-    rm -r verilator && \
-    ccache -C
+    rm -r verilator
 
 COPY verilator-wrap.sh /usr/local/bin/verilator-wrap.sh
 

ci/docker/run/README.rst

@@ -1,4 +1,4 @@
-.. Copyright 2003-2026 by Wilson Snyder.
+.. Copyright 2003-2024 by Wilson Snyder.
 .. SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 
 Verilator Executable Docker Container
@@ -11,12 +11,11 @@ easily as a docker image, e.g.:
 
    docker run -ti verilator/verilator:latest --version
 
-This will pull the container from `Docker Hub
-<https://hub.docker.com/r/verilator/verilator>`_, run the latest Verilator
-and print Verilator's version.
+This will install the container, run the latest Verilator and print
+Verilator's version.
 
-Containers are automatically built and pushed to docker hub for all
-released versions, so you may easily compare results across versions, e.g.:
+Containers are automatically built for all released versions, so you may
+easily compare results across versions, e.g.:
 
 ::
 
@@ -38,7 +37,7 @@ or
    ./verilator-docker 4.030 --cc test.v
 
 If you prefer not to use ``verilator-docker`` you must give the container
-access to your files as a volume with appropriate user rights. For example
+access to your files as a volume with appropriate user rights.  For example
 to Verilate test.v:
 
 ::
@@ -68,9 +67,9 @@ Internals
 The Dockerfile builds Verilator and removes the tree when completed to
 reduce the image size. The entrypoint is a wrapper script
 (``verilator-wrap.sh``). That script 1. calls Verilator, and 2. copies the
-Verilated runtime files to the ``obj_dir`` or the ``-Mdir`` respectively.
-This allows the user to have the files to they may later build the C++
-output with the matching runtime files. The wrapper also patches the
-Verilated Makefile accordingly.
+Verilated runtime files to the ``obj_dir`` or the ``-Mdir``
+respectively. This allows the user to have the files to they may later
+build the C++ output with the matching runtime files. The wrapper also
+patches the Verilated Makefile accordingly.
 
 A hook is also defined and run by Docker Hub via automated builds.

ci/docker/run/hooks/post_push

@@ -8,6 +8,6 @@
 # SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 
 if [ "$SOURCE_BRANCH"="stable" ]; then
-  docker tag $IMAGE_NAME $DOCKER_REPO:latest
-  docker push $DOCKER_REPO:latest
+    docker tag $IMAGE_NAME $DOCKER_REPO:latest
+    docker push $DOCKER_REPO:latest
 fi

ci/docker/run/verilator-wrap.sh

@@ -11,21 +11,21 @@
 perl /usr/local/bin/verilator "$@"
 status=$?
 if [ $status -ne 0 ]; then
-  exit $status
+    exit $status
 fi
 
 # Check if user set an obj_dir
 obj_dir=$(echo " $@" | grep -oP '\s--Mdir\s*\K\S+')
 if [ "$obj_dir" == "" ]; then
-  obj_dir="obj_dir"
+    obj_dir="obj_dir"
 fi
 
 # If the run was successful: Copy required files to allow build without this container
 if [ -e ${obj_dir} ]; then
-  # Copy files required for the build
-  mkdir -p ${obj_dir}/vlt
-  cp -r /usr/local/share/verilator/bin ${obj_dir}/vlt
-  cp -r /usr/local/share/verilator/include ${obj_dir}/vlt
-  # Point Makefile to that folder
-  sed -i 's/VERILATOR_ROOT = \/usr\/local\/share\/verilator/VERILATOR_ROOT = vlt/g' ${obj_dir}/*.mk
+    # Copy files required for the build
+    mkdir -p ${obj_dir}/vlt
+    cp -r /usr/local/share/verilator/bin ${obj_dir}/vlt
+    cp -r /usr/local/share/verilator/include ${obj_dir}/vlt
+    # Point Makefile to that folder
+    sed -i 's/VERILATOR_ROOT = \/usr\/local\/share\/verilator/VERILATOR_ROOT = vlt/g' ${obj_dir}/*.mk
 fi

codecov.yml

@@ -0,0 +1,38 @@
+# DESCRIPTION: codecov.io config
+#
+# Copyright 2020-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
+####################
+# 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,17 +1,16 @@
 # DESCRIPTION: Process this file with autoconf to produce a configure script.
 #
-# Copyright 2003-2026 by Wilson Snyder. Verilator is free software; you
+# Copyright 2003-2024 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.044 2026-01-01],
+AC_INIT([Verilator],[5.022 2024-02-24],
         [https://verilator.org],
         [verilator],[https://verilator.org])
 
@@ -30,9 +29,6 @@ AC_DEFINE_UNQUOTED([PACKAGE_VERSION_STRING_CHAR],
         [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],
               [AS_HELP_STRING([--disable-dependency-tracking], [ignored])])
@@ -57,22 +53,6 @@ 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],
@@ -85,27 +65,21 @@ AC_ARG_ENABLE([tcmalloc],
                 *)   AC_MSG_ERROR([bad value '${enableval}' for --enable-tcmalloc]) ;;
                esac],
               [CFG_WITH_TCMALLOC=check;])
-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
+AC_MSG_RESULT($CFG_WITH_TCMALLOC)
 
-# 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.
+# 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.
                                For developers only.])],
               [case "${enableval}" in
-                yes) CFG_WITH_DEV_GCOV=yes ;;
-                no)  CFG_WITH_DEV_GCOV=no ;;
-                *)   AC_MSG_ERROR([bad value '${enableval}' for --enable-dev-gcov]) ;;
+                yes) CFG_ENABLE_COVERAGE=yes ;;
+                no)  CFG_ENABLE_COVERAGE=no ;;
+                *)   AC_MSG_ERROR([bad value '${enableval}' for --enable-coverage]) ;;
                esac],
-               CFG_WITH_DEV_GCOV=no)
-AC_SUBST(CFG_WITH_DEV_GCOV)
-AC_MSG_RESULT($CFG_WITH_DEV_GCOV)
+               CFG_ENABLE_COVERAGE=no)
+AC_MSG_RESULT($CFG_ENABLE_COVERAGE)
 
 # Special Substitutions - CFG_WITH_DEFENV
 AC_MSG_CHECKING(whether to use hardcoded paths)
@@ -160,33 +134,6 @@ 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 "
@@ -199,10 +146,8 @@ AC_PROG_CXX
 AC_PROG_INSTALL
 
 AC_LANG_PUSH(C++)
-CFG_CXX_VERSION=`$CXX --version | head -1`
-AC_MSG_RESULT([compiler version... $CXX --version = $CFG_CXX_VERSION])
-AC_SUBST(CFG_CXX_VERSION)
-
+cxx_version=$($CXX --version | head -1)
+AC_MSG_RESULT([compiler is $CXX --version = $cxx_version])
 AC_MSG_CHECKING([that C++ compiler can compile simple program])
 AC_RUN_IFELSE(
    [AC_LANG_SOURCE([int main() { return 0; }])],
@@ -215,26 +160,24 @@ if test "x$AR" = "x" ; then
    AC_MSG_ERROR([Cannot find "ar" in your PATH, please install it])
 fi
 
-AC_CHECK_PROG(PERL,perl,perl)
+AC_PATH_PROG(PERL,perl)
 if test "x$PERL" = "x" ; then
    AC_MSG_ERROR([Cannot find "perl" in your PATH, please install it])
 fi
 
-AC_CHECK_PROG(PYTHON3,python3,python3)
+AC_PATH_PROG(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_CHECK_PROG(LEX,flex,flex)
+AC_PATH_PROG(LEX,flex)
 if test "x$LEX" = "x" ; then
    AC_MSG_ERROR([Cannot find "flex" in your PATH, please install it])
 fi
 flex_version=$($LEX --version | head -1)
 AC_MSG_RESULT([$LEX --version = $flex_version])
 
-AC_CHECK_PROG(YACC,bison,bison)
+AC_PATH_PROG(YACC,bison)
 if test "x$YACC" = "x" ; then
    AC_MSG_ERROR([Cannot find "bison" in your PATH, please install it])
 fi
@@ -323,43 +266,6 @@ 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
@@ -400,7 +306,7 @@ AC_DEFUN([_MY_LDLIBS_CHECK_OPT],
    ])
 
 # Add the coverage flags early as they influence later checks.
-if test "$CFG_WITH_DEV_GCOV" = "yes"; then
+if test "$CFG_ENABLE_COVERAGE" = "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
@@ -412,19 +318,11 @@ if test "$CFG_WITH_DEV_GCOV" = "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)
-  # 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
+  # Exceptions can pollute the branch coverage data
+  _MY_CXX_CHECK_OPT(CXX,-fno-exceptions)
+  # Define-out some impossible stuff
   _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)
@@ -453,29 +351,39 @@ _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_WEXTRA,-Wthread-safety)
 AC_SUBST(CFG_CXXFLAGS_WEXTRA)
 
 # Flags for coroutine support for dynamic scheduling
-_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)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_COROUTINES,-fcoroutines-ts)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_COROUTINES,-fcoroutines)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_COROUTINES,-fcoroutines-ts -Wno-deprecated-experimental-coroutine)
 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,-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)
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-fno-exceptions)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-unused-parameter)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-shadow)
 AC_SUBST(CFG_CXXFLAGS_SRC)
 
 # Flags for compiling Verilator parser always (in addition to above CFG_CXXFLAGS_SRC)
@@ -486,22 +394,16 @@ _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_WITH_DEV_GCOV" = "no"; then # Do not optimize for the coverage build
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_DBG,-Og)
+if test "$CFG_ENABLE_COVERAGE" = "no"; then # Do not optimize for the coverage build
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_DEBUG,-Og)
 fi
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_DBG,-ggdb)
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_DBG,-gz)
-AC_SUBST(CFG_CXXFLAGS_DBG)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_DEBUG,-ggdb)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_DEBUG,-gz)
+AC_SUBST(CFG_CXXFLAGS_DEBUG)
 
 # Flags for linking the debug version of Verilator (in addition to above CFG_LDFLAGS_SRC)
-_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)
+_MY_LDLIBS_CHECK_OPT(CFG_LDFLAGS_DEBUG,-gz)
+AC_SUBST(CFG_LDFLAGS_DEBUG)
 
 # Flags for Verilated makefile
 # For example, -Wno-div-by-zero isn't in 4.1.2
@@ -516,26 +418,22 @@ CFG_CXX_FLAGS_CMAKE="-faligned-new"
 m4_foreach([cflag],[
         [-fbracket-depth=4096],
         [-fcf-protection=none],
-        [-Xclang -fno-pch-timestamp],
         [-mno-cet],
         [-Qunused-arguments],
         [-Wno-bool-operation],
         [-Wno-c++11-narrowing],
         [-Wno-constant-logical-operand],
-        [-Wno-int-in-bool-context],
         [-Wno-non-pod-varargs],
         [-Wno-parentheses-equality],
         [-Wno-shadow],
         [-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-vla-cxx-extension]],[
+        [-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"
@@ -565,7 +463,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="-Wl,--whole-archive -l:libtcmalloc_minimal.a -Wl,--no-whole-archive"
+  LTCMALLOC=-l:libtcmalloc_minimal.a
 else
   LTCMALLOC=-ltcmalloc_minimal
 fi
@@ -589,17 +487,15 @@ _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 its own versions of the standard library functions
+    # it is using it's 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++14 at least
@@ -607,15 +503,18 @@ AC_SUBST(CFG_LIBS)
 AC_DEFUN([_MY_CXX_CHECK_CXX_VER],
    [# _MY_CXX_CHECK_CXX_VER(flag) -- Check if compiler runs C++14
     # Set $_my_result
-    AC_RUN_IFELSE(
+    AC_LINK_IFELSE(
      [AC_LANG_PROGRAM([#include <thread>
 #if (__cplusplus < 201402L)
 # error "Too old"
 #endif
-    ], [[
-     ]])],
-     [_my_result=yes],
-     [_my_result=no],
+    ], [[ ]])],
+     [_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=no])
    ])
 
@@ -685,9 +584,6 @@ 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 Verilator bug?
------------------------------
+Did you find a bug?
+-------------------
 
 - Please **ensure the bug was not already reported** by searching
   `Verilator Issues <https://verilator.org/issues>`__.
@@ -23,13 +23,13 @@ Did you find a Verilator bug?
     demonstrating the bug and expected behavior that is not occurring.
 
   - The ideal example works against other simulators, and is in the
-    test_regress/t test format, as described in `Verilator Internals
-    Documentation
+    test_regress/t test format, as described in
+    `Verilator Internals Documentation
     <https://github.com/verilator/verilator/blob/master/docs/internals.rst>`__.
 
 
-Did you write a patch that fixes a Verilator bug?
--------------------------------------------------
+Did you write a patch that fixes a bug?
+---------------------------------------
 
 - Please `Open a new Verilator issue <https://verilator.org/issues/new>`__
   if there is not one already describing the bug.
@@ -38,18 +38,18 @@ Did you write a patch that fixes a Verilator bug?
   <https://github.com/verilator/verilator/pulls>`__.
 
 - See the coding conventions, and other developer information in
-  ``docs/internals.rst`` in the distribution, or as rendered at `Verilator
-  Internals Documentation
+  ``docs/internals.rst`` in the distribution, or as rendered at
+  `Verilator Internals Documentation
   <https://github.com/verilator/verilator/blob/master/docs/internals.rst>`__.
 
-- Verilator uses GitHub Actions to provide continuous integration. You may
-  want to enable Actions on your GitHub branch to ensure your changes keep
-  the tests passing.
+- Verilator uses GitHub Actions to provide continuous integration.  You
+  may want to enable Actions on your GitHub branch to ensure your changes
+  keep the tests passing.
 
-- Your source-code contributions must be certified as open source, under
-  the `Developer Certificate of Origin
-  <https://developercertificate.org/>`__. On your first contribution, you
-  must either:
+- Your source-code contributions must be certified as open source,
+  under the `Developer Certificate of
+  Origin <https://developercertificate.org/>`__. On your first
+  contribution, you must either:
 
   - Have your patch include the addition of your name to `docs/CONTRIBUTORS
     <CONTRIBUTORS>`__ (preferred).
@@ -72,12 +72,12 @@ Did you write a patch that fixes a Verilator bug?
 - Most important is we get your patch.
 
 
-Do you have questions on Verilator?
------------------------------------
+Do you have questions?
+----------------------
 
-- Please see FAQ section and rest of the `Verilator manual
-  <https://verilator.org/verilator_doc.html>`__, or `Verilator manual (PDF)
-  <https://verilator.org/verilator_doc.pdf>`__.
+- Please see FAQ section and rest of the `Verilator
+  manual <https://verilator.org/verilator_doc.html>`__, or `Verilator
+  manual (PDF) <https://verilator.org/verilator_doc.pdf>`__.
 
 - Ask any question in the `Verilator forum
   <https://verilator.org/forum>`__.

docs/CONTRIBUTORS

@@ -3,84 +3,59 @@ 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)
-Aidan McNay
+Ahmed El-Mahmoudy
 Aleksander Kiryk
 Alex Chadwick
-Alex Solomatnikov
+Àlex Torregrosa
 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 Ruelas-Petrisko
+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
@@ -88,15 +63,12 @@ Huang Rui
 Huanghuang Zhou
 HungMingWu
 HyungKi Jeong
-Ibrahim Burak Yorulmaz
-Igor Zaworski
+Ícaro Lima
 Ilya Barkov
 Iru Cai
 Ivan Vnučec
 Iztok Jeras
 Jake Merdich
-Jakub Wasilewski
-James Bailey
 James Hanlon
 James Hutchinson
 James Pallister
@@ -104,28 +76,22 @@ James Shi
 Jamey Hicks
 Jamie Iles
 Jan Van Winkel
+Jiangjie Weng
 Jean Berniolles
-Jean-Nicolas Strauss
-Jens Yuechao Liu
 Jeremy Bennett
 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 Drowne
 Jose Loyola
 Josep Sans
 Joseph Nwabueze
@@ -137,22 +103,14 @@ 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
@@ -165,43 +123,27 @@ 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
+Michal Czyz
 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 Kojma
 Pawel Sagan
 Pengcheng Xu
-Peter Birch
 Peter Debacker
 Peter Horvath
 Peter Monsson
-Petr Nohavica
-Philip Axer
 Philipp Wagner
 Pierre-Henri Horrein
 Pieter Kapsenberg
@@ -211,22 +153,15 @@ 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
@@ -234,25 +169,18 @@ Steven Hugg
 Szymon Gizler
 Sören Tempel
 Teng Huang
-Thomas Aldrian
-Thomas Dybdahl Ahle
 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
@@ -261,9 +189,6 @@ Vito Gamberini
 William D. Jones
 Wilson Snyder
 Xi Zhang
-Yan Xu
-Yangyu Chen
-Yilou Wang
 Yinan Xu
 Yoda Lee
 Yossi Nivin
@@ -272,14 +197,6 @@ Yuri Victorovich
 Yutetsu TAKATSUKASA
 Yves Mathieu
 Zhanglei Wang
-Zhen Yan
 Zhou Shen
-Zhouyi Shen
 Zixi Li
-apocelipes
-dependabot[bot]
-february cozzocrea
-sumpster
-em2machine
-Àlex Torregrosa
-Ícaro Lima
+أحمد المحمودي

docs/Makefile

@@ -5,7 +5,7 @@
 #
 # Code available from: https://verilator.org
 #
-# Copyright 2003-2026 by Wilson Snyder. This program is free software; you
+# Copyright 2003-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.
@@ -23,9 +23,9 @@ SPHINXBUILD ?= sphinx-build
 SOURCEDIR = guide
 BUILDDIR = _build
 
-SPHINXOPTS ?= -c guide -j 4
+SPHINXOPTS ?= -c guide
 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,21 +68,15 @@ pdf:
 
 ######################################################################
 
-html latex linkcheck::
+html latex linkcheck spelling::
 	$(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

@@ -10,8 +10,8 @@ For formatted documentation see:
 - `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>`_
+- `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>`_

docs/bin/vl_sphinx_extract

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# mypy: disallow-untyped-defs
 # pylint: disable=C0112,C0114,C0115,C0116,C0209,C0301,R0903
 # -*- Python -*- See copyright, etc below
 ######################################################################
@@ -12,8 +11,9 @@ import re
 
 class VlSphinxExtract:
     debug = 0
+    SkipBasenames = {}
 
-    def process(self, filename: str) -> None:
+    def process(self, filename):
         with open(filename, "r", encoding="utf8") as fhr:
             fhw = None
             for line in fhr:
@@ -23,7 +23,9 @@ 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
@@ -37,14 +39,18 @@ parser = argparse.ArgumentParser(
     allow_abbrev=False,
     formatter_class=argparse.RawDescriptionHelpFormatter,
     description="""Read a file and extract documentation data.""",
-    epilog=""" Copyright 2021-2026 by Wilson Snyder.  This package is free software;
+    epilog=
+    """ Copyright 2021-2024 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,5 +1,4 @@
 #!/usr/bin/env python3
-# mypy: disallow-untyped-defs
 # pylint: disable=C0112,C0114,C0115,C0116,C0209,C0301,R0903
 # -*- Python -*- See copyright, etc below
 ######################################################################
@@ -13,17 +12,20 @@ import re
 
 class VlSphinxFix:
     debug = 0
+    SkipBasenames = {}
 
-    def process(self, path: str) -> None:
+    def process(self, path):
         if os.path.isdir(path):
             for basefile in os.listdir(path):
                 file = os.path.join(path, basefile)
-                if ((basefile != ".") and (basefile != "..") and not os.path.islink(file)):
+                if ((basefile != ".") and (basefile != "..")
+                        and basefile not in self.SkipBasenames
+                        and not os.path.islink(file)):
                     self.process(file)
         elif re.search(r'\.(html|tex)$', path):
             self._edit(path)
 
-    def _edit(self, filename: str) -> None:
+    def _edit(self, filename):
         is_html = re.search(r'\.(html)$', filename)
         with open(filename, "r", encoding="utf8") as fhr:
             origfile = fhr.read()
@@ -52,14 +54,18 @@ parser = argparse.ArgumentParser(
     allow_abbrev=False,
     formatter_class=argparse.RawDescriptionHelpFormatter,
     description="""Post-process Sphinx HTML.""",
-    epilog=""" Copyright 2021-2026 by Wilson Snyder.  This package is free software;
+    epilog=
+    """ Copyright 2021-2024 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

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

docs/gen/ex_ALWNEVER_msg.rst

@@ -1,4 +0,0 @@
-.. 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

@@ -1,8 +0,0 @@
-.. comment: generated by t_lint_assigneqexpr_bad
-.. code-block:: sv
-   :linenos:
-
-       output logic c_o,
-       output logic d_o
-   );
-     assign c_o = (a_i != 0) ? 1 : 0;

docs/gen/ex_ASSIGNEQEXPR_msg.rst

@@ -1,5 +0,0 @@
-.. 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

@@ -1,5 +0,0 @@
-.. 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

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

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 after 100 tries
+   %Error: t/t_lint_didnotconverge_bad.v:7: Settle region did not converge.

docs/gen/ex_FUNCTIMECTL_faulty.rst

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

@@ -1,4 +0,0 @@
-.. 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

@@ -1,8 +0,0 @@
-.. 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

@@ -1,7 +0,0 @@
-.. 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: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
+   %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

docs/gen/ex_NORETURN_faulty.rst

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

@@ -1,4 +0,0 @@
-.. 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

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

@@ -1,6 +0,0 @@
-.. 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

@@ -1,11 +0,0 @@
-.. 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

@@ -1,4 +0,0 @@
-.. 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

@@ -1,12 +0,0 @@
-.. 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

@@ -1,15 +0,0 @@
-.. 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

@@ -1,12 +0,0 @@
-.. 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:5 Ignoring delay on this statement due to --no-timing
+   %Warning-STMTDLY: example.v:1:7 Ignoring delay on this statement due to --no-timing

docs/gen/ex_SUPERNFIRST_faulty.rst

@@ -1,8 +0,0 @@
-.. comment: generated by t_class_new_supernfirst_bad
-.. code-block:: sv
-   :linenos:
-   :emphasize-lines: 3
-
-     function new();
-       int x = $random();
-       super.new(build_coverage(x), x);  // <--- BAD, must be first statement

docs/gen/ex_SUPERNFIRST_msg.rst

@@ -1,4 +0,0 @@
-.. comment: generated by t_class_new_supernfirst_bad
-.. code-block::
-
-   %Error-SUPERNFIRST: example.v:1:11 'super.new' must be first statement in a 'function new' (IEEE 1800-2023 8.15)

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:5 User elaboration-time error
+   %Warning-USERERROR: example.v:1:7 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:5 User elaboration-time fatal
+   %Warning-USERFATAL: example.v:1:7 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:5 User elaboration-time info
+   -Info: example.v:1:7 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:5 User elaboration-time warning
+   %Warning-USERWARN: example.v:1:7 User elaboration-time warning